示例#1
0
	public void SetCreationData( EntityCreationData _data)
	{
		switch( _data.creationType_)
		{
		case eCreationType.NPC_APPEAR:
			SetCreationData( _data as NpcAppearData);
			break;
		case eCreationType.PET_APPEAR:
			SetCreationData( _data as PetAppearData);
			break;
		}
	}
 private static void Penalty(string _id)
 {
     try
     {
         PlayerDataFile _playerDataFile = PersistentOperations.GetPlayerDataFileFromSteamId(_id);
         if (_playerDataFile != null)
         {
             PersistentPlayerData _persistentPlayerData = PersistentOperations.GetPersistentPlayerDataFromSteamId(_id);
             if (_persistentPlayerData != null)
             {
                 GC.Collect();
                 MemoryPools.Cleanup();
                 EntityBackpack entityBackpack = new EntityBackpack();
                 entityBackpack               = EntityFactory.CreateEntity("Backpack".GetHashCode(), _playerDataFile.ecd.pos + Vector3.up * 2f) as EntityBackpack;
                 entityBackpack.RefPlayerId   = _playerDataFile.ecd.clientEntityId;
                 entityBackpack.lootContainer = new TileEntityLootContainer(null);
                 entityBackpack.lootContainer.SetUserAccessing(true);
                 entityBackpack.lootContainer.SetEmpty();
                 entityBackpack.lootContainer.lootListIndex = entityBackpack.GetLootList();
                 entityBackpack.lootContainer.SetContainerSize(LootContainer.lootList[entityBackpack.GetLootList()].size, true);
                 if (All || Bag)
                 {
                     for (int i = 0; i < _playerDataFile.bag.Length; i++)
                     {
                         if (!_playerDataFile.bag[i].IsEmpty())
                         {
                             entityBackpack.lootContainer.AddItem(_playerDataFile.bag[i]);
                             _playerDataFile.bag[i] = ItemStack.Empty.Clone();
                         }
                     }
                 }
                 if (All || Belt)
                 {
                     for (int i = 0; i < _playerDataFile.inventory.Length; i++)
                     {
                         if (!_playerDataFile.inventory[i].IsEmpty())
                         {
                             entityBackpack.lootContainer.AddItem(_playerDataFile.inventory[i]);
                             _playerDataFile.inventory[i] = ItemStack.Empty.Clone();
                         }
                     }
                 }
                 if (All || Equipment)
                 {
                     ItemValue[] _equipmentValues = _playerDataFile.equipment.GetItems();
                     for (int i = 0; i < _equipmentValues.Length; i++)
                     {
                         if (!_equipmentValues[i].IsEmpty())
                         {
                             entityBackpack.lootContainer.AddItem(new ItemStack(_equipmentValues[i], 1));
                         }
                     }
                     if (!_playerDataFile.equipment.HasAnyItems())
                     {
                         _playerDataFile.equipment = new Equipment();
                     }
                 }
                 _playerDataFile.droppedBackpackPosition      = new Vector3i(_playerDataFile.ecd.pos);
                 entityBackpack.lootContainer.bPlayerBackpack = true;
                 entityBackpack.lootContainer.SetUserAccessing(false);
                 entityBackpack.lootContainer.SetModified();
                 entityBackpack.entityId    = -1;
                 entityBackpack.RefPlayerId = _playerDataFile.ecd.clientEntityId;
                 EntityCreationData entityCreationData = new EntityCreationData(entityBackpack);
                 entityCreationData.entityName    = string.Format(Localization.Get("playersBackpack", ""), _playerDataFile.ecd.entityName);
                 entityCreationData.id            = -1;
                 entityCreationData.lootContainer = entityBackpack.lootContainer.Clone();
                 PersistentOperations.SavePlayerDataFile(_id, _playerDataFile);
                 GameManager.Instance.RequestToSpawnEntityServer(entityCreationData);
                 entityBackpack.OnEntityUnload();
                 BattleLogger.Players.Remove(_id);
             }
         }
     }
     catch (Exception e)
     {
         Log.Out(string.Format("[SERVERTOOLS] Error in BattleLogger.Penalty: {0}.", e.Message));
     }
 }
示例#3
0
        public void Read(BinaryReader _br, uint _version)
        {
            //ECD
            ecd = new EntityCreationData();
            ecd.read(_br, false);

            //FOOD/DRINK
            food = new LiveStats(Constants.cMaxPlayerFood, Constants.cFoodOversaturate);
            food.Read(_br);
            drink = new LiveStats(Constants.cMaxPlayerDrink, Constants.cDrinkOversaturate);
            drink.Read(_br);

            //INVENTORY
            inventory             = GameUtils.ReadItemStack(_br);
            selectedInventorySlot = _br.ReadByte();

            //BAG
            bag = GameUtils.ReadItemStack(_br);
            //REMOVED - To allow for bigger backpack mods
            //if (bag.Length > 32)
            //{
            //  var destinationArray = ItemStack.CreateArray(32);
            //  Array.Copy(bag, destinationArray, 32);
            //  bag = destinationArray;
            //}

            //CRAFTED
            alreadyCraftedList = new HashSet <string>();
            int num = _br.ReadUInt16();

            for (var i = 0; i < num; i++)
            {
                alreadyCraftedList.Add(_br.ReadString());
            }

            //SPAWNS
            var b = _br.ReadByte();

            for (var j = 0; j < b; j++)
            {
                spawnPoints.Add(new Vector3i(_br.ReadInt32(), _br.ReadInt32(), _br.ReadInt32()));
            }
            selectedSpawnPointKey = _br.ReadInt64();

            //LOADED
            _br.ReadBoolean();
            _br.ReadInt16();
            if (_version > 1u)
            {
                bLoaded = _br.ReadBoolean();
            }

            //LASTSPAWN
            if (_version > 2u)
            {
                lastSpawnPosition = new SpawnPosition(new Vector3i(_br.ReadInt32(), _br.ReadInt32(), _br.ReadInt32()), _br.ReadSingle());
            }
            else if (_version > 1u)
            {
                lastSpawnPosition = new SpawnPosition(new Vector3i(_br.ReadInt32(), _br.ReadInt32(), _br.ReadInt32()), 0f);
            }

            //ID
            if (_version > 3u)
            {
                id = _br.ReadInt32();
            }

            //BACKPACK
            if (_version > 4u)
            {
                droppedBackpackPosition = new Vector3i(_br.ReadInt32(), _br.ReadInt32(), _br.ReadInt32());
            }

            //STATS/EQUIPMENT
            if (_version > 5u)
            {
                playerKills = _br.ReadInt32();
                zombieKills = _br.ReadInt32();
                deaths      = _br.ReadInt32();
                score       = _br.ReadInt32();
                equipment   = Equipment.Read(_br);
            }

            //RECIPES
            if (_version > 6u)
            {
                unlockedRecipeList = new List <string>();
                num = _br.ReadUInt16();
                for (var k = 0; k < num; k++)
                {
                    unlockedRecipeList.Add(_br.ReadString());
                }
            }

            //MARKER
            if (_version > 7u)
            {
                _br.ReadUInt16();
                markerPosition = NetworkUtils.ReadVector3i(_br);
            }

            //FAVS
            if (_version > 8u)
            {
                favoriteEquipment = Equipment.Read(_br);
            }

            //EXP
            if (_version > 10u)
            {
                experience = _br.ReadUInt32();
            }

            //LEVEL
            if (_version > 22u)
            {
                level = _br.ReadInt32();
            }

            //CROUCHED
            if (_version > 11u)
            {
                bCrouchedLocked = _br.ReadBoolean();
            }

            //CRAFTINGDATA
            craftingData.Read(_br, _version);

            //SKILLS - part1
            if (_version > 14u)
            {
                if (_version < 18u)
                {
                    var pdfskills = new Skills();
                    pdfskills.Read(_br, _version);
                }
            }

            //FAVRECIPES
            if (_version > 16u)
            {
                favoriteRecipeList = new List <string>();
                num = _br.ReadUInt16();
                for (var l = 0; l < num; l++)
                {
                    favoriteRecipeList.Add(_br.ReadString());
                }
            }

            //SKILLS - part2
            if (_version > 17u)
            {
                var num2 = (int)_br.ReadUInt32();
                if (num2 > 0)
                {
                    //custom skill loader
                    var pdfskills = new MemoryStream(_br.ReadBytes(num2));

                    var skillsReader = new Skills();
                    skillsReader.Read(new BinaryReader(pdfskills), _version);
                    skills = skillsReader.GetAllSkills();
                    //end custom skill loader
                }
            }

            //STATS
            if (_version > 18u)
            {
                totalItemsCrafted = _br.ReadUInt32();
                distanceWalked    = _br.ReadSingle();
                longestLife       = _br.ReadSingle();
            }

            if (_version > 35u)
            {
                gameStageLifetimeTicks = _br.ReadUInt64();
            }
            else
            {
                gameStageLifetimeTicks = 0uL;
            }

            if (_version > 19u)
            {
                waypoints = new WaypointCollection();
                waypoints.Read(_br);
            }
            if (_version > 23u)
            {
                skillPoints = _br.ReadInt32();
            }
            if (_version > 24u)
            {
                questJournal = new QuestJournal();
                questJournal.Read(_br);
            }
            if (_version > 25u)
            {
                deathUpdateTime = _br.ReadInt32();
            }
            if (_version > 26u)
            {
                currentLife = _br.ReadSingle();
            }
            if (_version > 29u)
            {
                bDead = _br.ReadBoolean();
            }
            if (_version > 30u)
            {
                _br.ReadByte();
                IsModdedSave = _br.ReadBoolean();
            }
            if (_version > 31u)
            {
                playerJournal = new PlayerJournal();
                playerJournal.Read(_br);
            }
            if (_version > 32u)
            {
                rentedVMPosition = NetworkUtils.ReadVector3i(_br);
                rentalEndTime    = _br.ReadUInt64();
            }
            if (_version > 33u)
            {
                trackedFriendEntityIds.Clear();
                int num3 = _br.ReadUInt16();
                for (var m = 0; m < num3; m++)
                {
                    trackedFriendEntityIds.Add(_br.ReadInt32());
                }
            }
            if (_version > 34u)
            {
                var num4 = _br.ReadInt32();
                if (num4 > 0)
                {
                    //var pdfstealth = new MemoryStream(_br.ReadBytes(num4));
                    //todo: custom loader
                }
            }
        }
示例#4
0
	public void SetCreationData( EntityCreationData _data)
	{
		switch( _data.creationType_)
		{
		case eCreationType.CHAR_LOAD_RESULT:
			SetCreationData( _data as CharacterLoadData);
			break;
		case eCreationType.CHAR_LOAD_RESULT_EMPTY:
			SetEmptySlotData();
			break;
		case eCreationType.OTHER_CHAR_APPEAR:
			SetCreationData( _data as OtherCharacterAppearData);
			break;
		case eCreationType.CHARACTER_SELECT:
			SetCreationData( _data as CharacterSelectEntityData);
			break;
		default:
			Debug.LogError( "AsUserEntity::SetCreationData: unknown creation type( " + _data.creationType_ + ")");
			break;
		}
	}
示例#5
0
        /// <summary>
        /// Generates object from unzipped chunk data. Do not use with the MemoryStreams held in region object.
        /// </summary>
        /// <param name="data">Unzipped chunk data in form of a memory stream.</param>
        public void Read(MemoryStream data)
        {
            BinaryReader reader = new BinaryReader(data);

            xm = reader.ReadInt32();
            mm = reader.ReadInt32();
            rm = reader.ReadInt32();

            savedInWorldTicks = reader.ReadUInt64();

            for (int i = 0; i < 64; ++i)
            {
                bool flag = reader.ReadBoolean();

                if (flag)
                {
                    cbl[i] = new ChunkBlockLayer();
                    cbl[i].Read(reader);
                }
            }

            cbc = new ChunkBlockChannel();
            cbc.Read(reader);

            reader.Read(im, 0, 256);
            reader.Read(terrainHeight, 0, 256);
            reader.Read(biomeId, 0, 256);
            reader.Read(biomeIntensity, 0, 1536);

            dominantBiome           = reader.ReadByte();
            areaMasterDominantBiome = reader.ReadByte();

            int chunkCustomDataCount = (int)reader.ReadUInt16();

            for (int j = 0; j < chunkCustomDataCount; ++j)
            {
                ChunkCustomData chunkCustomData = new ChunkCustomData();
                chunkCustomData.Read(reader);
                chunkCustomDataDictionary[chunkCustomData.key] = chunkCustomData;
            }

            reader.Read(pr, 0, 256);
            reader.Read(jr, 0, 256);
            reader.Read(fr, 0, 256);

            cm.Read(reader);
            vm.Read(reader);
            gm.Read(reader);
            km.Read(reader);

            needsLightCalculation = reader.ReadBoolean();

            int entityCount = reader.ReadInt32();

            for (int k = 0; k < entityCount; ++k)
            {
                EntityCreationData entityCreationData = new EntityCreationData();
                entityCreationData.Read(reader);
                entityCreationDataList.Add(entityCreationData);
            }

            int tileEntityCount = reader.ReadInt32();

            for (int l = 0; l < tileEntityCount; ++l)
            {
                TileEntityType type       = (TileEntityType)reader.ReadInt32();
                TileEntity     tileEntity = TileEntity.Instantiate(type);
                tileEntity.Read(reader);

                tileEntityDictionary[tileEntity.localChunkPosition] = tileEntity;
            }

            int entitySpawnerCount = (int)reader.ReadUInt16();

            entitySpawnerSaveVersion = (uint)reader.ReadByte();

            for (int m = 0; m < entitySpawnerCount; ++m)
            {
                EntitySpawner entitySpawner = new EntitySpawner();
                entitySpawner.Read(reader);
                entitySpawnerList.Add(entitySpawner);
            }

            bool flag2 = reader.ReadBoolean();

            if (flag2)
            {
                ur = new ushort[16];
                for (int n = 0; n < 16; ++n)
                {
                    ur[n] = reader.ReadUInt16();
                }
            }
        }
示例#6
0
 private static void Penalty(ClientInfo _cInfo)
 {
     try
     {
         PlayerDataFile _pdf = PersistentOperations.GetPlayerDataFileFromSteamId(_cInfo.playerId);
         if (_pdf != null)
         {
             Vector3i _pos = new Vector3i((int)_pdf.ecd.pos.x, (int)_pdf.ecd.pos.y, (int)_pdf.ecd.pos.z);
             if (GameManager.Instance.World.IsChunkAreaLoaded(_pos.x, _pos.y, _pos.z))
             {
                 Chunk chunk = (Chunk)GameManager.Instance.World.GetChunkFromWorldPos(_pos.x, _pos.y, _pos.z);
                 if (chunk != null)
                 {
                     BlockValue _blockValue = Block.GetBlockValue("cntStorageChest");
                     if (_blockValue.Block != null)
                     {
                         GameManager.Instance.World.SetBlockRPC(chunk.ClrIdx, _pos, _blockValue);
                         TileEntityLootContainer tileEntityLootContainer = GameManager.Instance.World.GetTileEntity(chunk.ClrIdx, _pos) as TileEntityLootContainer;
                         if (tileEntityLootContainer != null)
                         {
                             if (All || Bag)
                             {
                                 for (int i = 0; i < _pdf.bag.Length; i++)
                                 {
                                     if (!_pdf.bag[i].IsEmpty())
                                     {
                                         tileEntityLootContainer.AddItem(_pdf.bag[i]);
                                         _pdf.bag[i] = ItemStack.Empty.Clone();
                                     }
                                 }
                             }
                             if (All || Belt)
                             {
                                 for (int i = 0; i < _pdf.inventory.Length; i++)
                                 {
                                     if (!_pdf.inventory[i].IsEmpty())
                                     {
                                         tileEntityLootContainer.AddItem(_pdf.inventory[i]);
                                         _pdf.inventory[i] = ItemStack.Empty.Clone();
                                     }
                                 }
                             }
                             if (All || Equipment)
                             {
                                 ItemValue[] _equipmentValues = _pdf.equipment.GetItems();
                                 for (int i = 0; i < _equipmentValues.Length; i++)
                                 {
                                     if (!_equipmentValues[i].IsEmpty())
                                     {
                                         ItemStack _itemStack = new ItemStack(_equipmentValues[i], 1);
                                         tileEntityLootContainer.AddItem(_itemStack);
                                         _equipmentValues[i].Clear();
                                     }
                                 }
                             }
                             if (tileEntityLootContainer.IsEmpty())
                             {
                                 GameManager.Instance.World.SetBlockRPC(chunk.ClrIdx, _pos, BlockValue.Air);
                             }
                             else
                             {
                                 tileEntityLootContainer.SetModified();
                             }
                             PersistentOperations.SavePlayerDataFile(_cInfo.playerId, _pdf);
                         }
                     }
                 }
             }
             else
             {
                 ChunkManager.ChunkObserver _observer = GameManager.Instance.AddChunkObserver(_pos.ToVector3(), false, 2, -1);
                 if (_observer != null)
                 {
                     Thread.Sleep(1000);
                     Chunk _chunk = (Chunk)GameManager.Instance.World.GetChunkFromWorldPos(_pos.x, _pos.y, _pos.z);
                     if (_chunk != null)
                     {
                         EntityBackpack entityBackpack = new EntityBackpack();
                         entityBackpack               = EntityFactory.CreateEntity("Backpack".GetHashCode(), _pdf.ecd.pos + Vector3.up * 2f) as EntityBackpack;
                         entityBackpack.RefPlayerId   = _pdf.ecd.clientEntityId;
                         entityBackpack.lootContainer = new TileEntityLootContainer(null);
                         entityBackpack.lootContainer.SetUserAccessing(true);
                         entityBackpack.lootContainer.SetEmpty();
                         entityBackpack.lootContainer.lootListIndex = entityBackpack.GetLootList();
                         entityBackpack.lootContainer.SetContainerSize(LootContainer.lootList[entityBackpack.GetLootList()].size, true);
                         if (All || Bag)
                         {
                             for (int i = 0; i < _pdf.bag.Length; i++)
                             {
                                 if (!_pdf.bag[i].IsEmpty())
                                 {
                                     entityBackpack.lootContainer.AddItem(_pdf.bag[i]);
                                     _pdf.bag[i] = ItemStack.Empty.Clone();
                                 }
                             }
                         }
                         if (All || Belt)
                         {
                             for (int i = 0; i < _pdf.inventory.Length; i++)
                             {
                                 if (!_pdf.inventory[i].IsEmpty())
                                 {
                                     entityBackpack.lootContainer.AddItem(_pdf.inventory[i]);
                                     _pdf.inventory[i] = ItemStack.Empty.Clone();
                                 }
                             }
                         }
                         if (All || Equipment)
                         {
                             ItemValue[] _equipmentValues = _pdf.equipment.GetItems();
                             for (int i = 0; i < _equipmentValues.Length; i++)
                             {
                                 if (!_equipmentValues[i].IsEmpty())
                                 {
                                     ItemStack _itemStack = new ItemStack(_equipmentValues[i], 1);
                                     entityBackpack.lootContainer.AddItem(_itemStack);
                                     _equipmentValues[i].Clear();
                                 }
                             }
                         }
                         _pdf.droppedBackpackPosition = new Vector3i(_pdf.ecd.pos);
                         entityBackpack.lootContainer.bPlayerBackpack = true;
                         entityBackpack.lootContainer.SetUserAccessing(false);
                         entityBackpack.lootContainer.SetModified();
                         entityBackpack.entityId    = -1;
                         entityBackpack.RefPlayerId = _pdf.ecd.clientEntityId;
                         EntityCreationData entityCreationData = new EntityCreationData(entityBackpack);
                         entityCreationData.entityName    = string.Format(Localization.Get("playersBackpack"), _pdf.ecd.entityName);
                         entityCreationData.id            = -1;
                         entityCreationData.lootContainer = entityBackpack.lootContainer.Clone();
                         PersistentOperations.SavePlayerDataFile(_cInfo.playerId, _pdf);
                         GameManager.Instance.RequestToSpawnEntityServer(entityCreationData);
                         entityBackpack.OnEntityUnload();
                     }
                     GameManager.Instance.RemoveChunkObserver(_observer);
                 }
             }
         }
     }
     catch (Exception e)
     {
         Log.Out(string.Format("[SERVERTOOLS] Error in ExitCommand.Penalty: {0}", e.Message));
     }
 }
示例#7
0
        public void Read(BinaryReader _br, uint _version)
        {
            ecd = new EntityCreationData();
            ecd.read(_br, false);
            food = new LiveStats(Constants.cMaxPlayerFood, Constants.cFoodOversaturate);
            food.Read(_br);
            drink = new LiveStats(Constants.cMaxPlayerDrink, Constants.cDrinkOversaturate);
            drink.Read(_br);
            inventory             = GameUtils.ReadItemStack(_br);
            selectedInventorySlot = _br.ReadByte();
            bag = GameUtils.ReadItemStack(_br);
            if (bag.Length > 32)
            {
                ItemStack[] destinationArray = ItemStack.CreateArray(32);
                Array.Copy(bag, destinationArray, 32);
                bag = destinationArray;
            }
            alreadyCraftedList = new HashSet <string>();
            int num = _br.ReadUInt16();

            for (int i = 0; i < num; i++)
            {
                alreadyCraftedList.Add(_br.ReadString());
            }
            byte b = _br.ReadByte();

            for (int j = 0; j < b; j++)
            {
                spawnPoints.Add(new Vector3i(_br.ReadInt32(), _br.ReadInt32(), _br.ReadInt32()));
            }
            selectedSpawnPointKey = _br.ReadInt64();
            _br.ReadBoolean();
            _br.ReadInt16();
            if (_version > 1u)
            {
                bLoaded = _br.ReadBoolean();
            }
            if (_version > 2u)
            {
                lastSpawnPosition = new SpawnPosition(new Vector3i(_br.ReadInt32(), _br.ReadInt32(), _br.ReadInt32()), _br.ReadSingle());
            }
            else if (_version > 1u)
            {
                lastSpawnPosition = new SpawnPosition(new Vector3i(_br.ReadInt32(), _br.ReadInt32(), _br.ReadInt32()), 0f);
            }
            if (_version > 3u)
            {
                id = _br.ReadInt32();
            }
            if (_version > 4u)
            {
                droppedBackpackPosition = new Vector3i(_br.ReadInt32(), _br.ReadInt32(), _br.ReadInt32());
            }
            if (_version > 5u)
            {
                playerKills = _br.ReadInt32();
                zombieKills = _br.ReadInt32();
                deaths      = _br.ReadInt32();
                score       = _br.ReadInt32();
                equipment   = Equipment.Read(_br);
            }
            if (_version > 6u)
            {
                unlockedRecipeList = new List <string>();
                num = _br.ReadUInt16();
                for (int k = 0; k < num; k++)
                {
                    unlockedRecipeList.Add(_br.ReadString());
                }
            }
            if (_version > 7u)
            {
                _br.ReadUInt16();
                markerPosition = NetworkUtils.ReadVector3i(_br);
            }
            if (_version > 8u)
            {
                favoriteEquipment = Equipment.Read(_br);
            }
            if (_version > 10u)
            {
                experience = _br.ReadUInt32();
            }
            if (_version > 22u)
            {
                level = _br.ReadInt32();
            }
            if (_version > 11u)
            {
                bCrouchedLocked = _br.ReadBoolean();
            }
            craftingData.Read(_br, _version);

            if (_version > 14u)
            {
                if (_version < 18u)
                {
                    Skills pdfskills = new Skills();
                    pdfskills.Read(_br, _version);
                }
            }
            if (_version > 16u)
            {
                favoriteRecipeList = new List <string>();
                num = _br.ReadUInt16();
                for (int l = 0; l < num; l++)
                {
                    favoriteRecipeList.Add(_br.ReadString());
                }
            }
            if (_version > 17u)
            {
                int num2 = (int)_br.ReadUInt32();
                if (num2 > 0)
                {
                    //custom skill loader
                    MemoryStream pdfskills = new MemoryStream(0);
                    pdfskills = new MemoryStream(_br.ReadBytes(num2));
                    EntityPlayer EP = new EntityPlayer();
                    EP.Skills = new Skills();
                    if (pdfskills.Length > 0L)
                    {
                        EP.Skills.Read(new BinaryReader(pdfskills), 34u);
                    }
                    skills = EP.Skills.GetAllSkills();
                    //end custom skill loader
                }
            }
            if (_version > 18u)
            {
                totalItemsCrafted = _br.ReadUInt32();
                distanceWalked    = _br.ReadSingle();
                longestLife       = _br.ReadSingle();
            }
            if (_version > 19u)
            {
                waypoints = new WaypointCollection();
                waypoints.Read(_br);
            }
            if (_version > 23u)
            {
                skillPoints = _br.ReadInt32();
            }
            if (_version > 24u)
            {
                questJournal = new QuestJournal();
                questJournal.Read(_br);
            }
            if (_version > 25u)
            {
                deathUpdateTime = _br.ReadInt32();
            }
            if (_version > 26u)
            {
                currentLife = _br.ReadSingle();
            }
            if (_version > 29u)
            {
                bDead = _br.ReadBoolean();
            }
            if (_version > 30u)
            {
                _br.ReadByte();
                IsModdedSave = _br.ReadBoolean();
            }
            if (_version > 31u)
            {
                playerJournal = new PlayerJournal();
                playerJournal.Read(_br);
            }
            if (_version > 32u)
            {
                rentedVMPosition = NetworkUtils.ReadVector3i(_br);
                rentalEndTime    = _br.ReadUInt64();
            }
            if (_version > 33u)
            {
                trackedFriendEntityIds.Clear();
                int num3 = _br.ReadUInt16();
                for (int m = 0; m < num3; m++)
                {
                    trackedFriendEntityIds.Add(_br.ReadInt32());
                }
            }
        }