Ignore:
Timestamp:
Sep 4, 2018, 1:00:48 PM (6 years ago)
Author:
alloc
Message:

Code style cleanup (mostly whitespace changes, enforcing braces, using cleanup)

File:
1 edited

Legend:

Unmodified
Added
Removed

  • binary-improvements/7dtd-server-fixes/src/PersistentData/Player.cs

    r324 r325  
    44
    55namespace AllocsFixes.PersistentData {
    6     [Serializable]
    7     public class Player {
    8         private readonly string steamId;
    9         private int entityId;
    10         private string name;
    11         private string ip;
    12         private long totalPlayTime;
    13 
    14         [OptionalField] private DateTime
    15             lastOnline;
    16 
    17         private Inventory inventory;
    18 
    19         [OptionalField] private int
    20             lastPositionX, lastPositionY, lastPositionZ;
    21 
    22         [OptionalField] [Obsolete ("experience no longer available, use level and expToNextLevel instead")]
    23         private uint experience;
    24 
    25         [OptionalField] private bool chatMuted;
    26         [OptionalField] private int maxChatLength;
    27         [OptionalField] private string chatColor;
    28         [OptionalField] private bool chatName;
    29         [OptionalField] private uint expToNextLevel;
    30         [OptionalField] private int level;
    31 
    32         [NonSerialized] private ClientInfo
    33             clientInfo;
    34 
    35         public string SteamID {
    36             get { return steamId; }
    37         }
     6        [Serializable]
     7        public class Player {
     8                private readonly string steamId;
     9                private int entityId;
     10                private string name;
     11                private string ip;
     12                private long totalPlayTime;
     13
     14                [OptionalField] private DateTime lastOnline;
     15
     16                private Inventory inventory;
     17
     18                [OptionalField] private int lastPositionX, lastPositionY, lastPositionZ;
     19
     20                [OptionalField] [Obsolete ("experience no longer available, use level and expToNextLevel instead")]
     21                private uint experience;
     22
     23                [OptionalField] private bool chatMuted;
     24                [OptionalField] private int maxChatLength;
     25                [OptionalField] private string chatColor;
     26                [OptionalField] private bool chatName;
     27                [OptionalField] private uint expToNextLevel;
     28                [OptionalField] private int level;
     29
     30                [NonSerialized] private ClientInfo clientInfo;
     31
     32                public string SteamID {
     33                        get { return steamId; }
     34                }
    3835
    3936        public int EntityID {
    … …  
    4138        }
    4239
    43         public string Name {
    44             get { return name == null ? string.Empty : name; }
    45         }
    46 
    47         public string IP {
    48             get { return ip == null ? string.Empty : ip; }
    49         }
    50 
    51         public Inventory Inventory {
    52             get {
    53                 if (inventory == null)
    54                     inventory = new Inventory ();
    55                 return inventory;
    56             }
    57         }
    58 
    59         public bool IsOnline {
    60             get { return clientInfo != null; }
    61         }
    62 
    63         public ClientInfo ClientInfo {
    64             get { return clientInfo; }
    65         }
    66 
    67         public EntityPlayer Entity {
    68             get {
    69                 if (IsOnline) {
    70                     return GameManager.Instance.World.Players.dict [clientInfo.entityId];
    71                 } else {
    72                     return null;
    73                 }
    74             }
    75         }
    76 
    77         public long TotalPlayTime {
    78             get {
    79                 if (IsOnline) {
    80                     return totalPlayTime + (long) (DateTime.Now - lastOnline).TotalSeconds;
    81                 } else {
    82                     return totalPlayTime;
    83                 }
    84             }
    85         }
    86 
    87         public DateTime LastOnline {
    88             get {
    89                 if (IsOnline)
    90                     return DateTime.Now;
    91                 else
    92                     return lastOnline;
    93             }
    94         }
    95 
    96         public Vector3i LastPosition {
    97             get {
    98                 if (IsOnline)
    99                     return new Vector3i (Entity.GetPosition ());
    100                 else
    101                     return new Vector3i (lastPositionX, lastPositionY, lastPositionZ);
    102             }
    103         }
    104 
    105         public bool LandProtectionActive {
    106             get {
    107                 return GameManager.Instance.World.IsLandProtectionValidForPlayer (GameManager.Instance
    108                     .GetPersistentPlayerList ().GetPlayerData (SteamID));
    109             }
    110         }
    111 
    112         public float LandProtectionMultiplier {
    113             get {
    114                 return GameManager.Instance.World.GetLandProtectionHardnessModifierForPlayer (GameManager.Instance
    115                     .GetPersistentPlayerList ().GetPlayerData (SteamID));
    116             }
    117         }
    118 
    119 
    120         [Obsolete ("Experience no longer available, use Level instead")]
    121         public uint Experience {
    122             get { return 0; }
    123         }
    124 
    125         public float Level {
    126             get {
    127                 float expForNextLevel =
    128                     (int) Math.Min ((Progression.BaseExpToLevel * Mathf.Pow (Progression.ExpMultiplier, level + 1)),
    129                         int.MaxValue);
    130                 float fLevel = level + 1f - ((float) expToNextLevel / expForNextLevel);
    131                 return fLevel;
    132             }
    133         }
    134 
    135         public bool IsChatMuted {
    136             get { return chatMuted; }
    137             set { chatMuted = value; }
    138         }
    139 
    140         public int MaxChatLength {
    141             get {
    142                 if (maxChatLength == 0) {
    143                     maxChatLength = 255;
    144                 }
    145 
    146                 return maxChatLength;
    147             }
    148             set { maxChatLength = value; }
    149         }
    150 
    151         public string ChatColor {
    152             get {
    153                 if (chatColor == null || chatColor == "") {
    154                     chatColor = "";
    155                 }
    156 
    157                 return chatColor;
    158             }
    159 
    160             set { chatColor = value; }
    161         }
    162 
    163         public bool ChatName {
    164             get { return chatName; }
    165 
    166             set { chatName = value; }
    167         }
    168 
    169         public void SetOffline () {
    170             if (clientInfo != null) {
    171                 Log.Out ("Player set to offline: " + steamId);
    172                 lastOnline = DateTime.Now;
    173                 try {
    174                     Vector3i lastPos = new Vector3i (Entity.GetPosition ());
    175                     lastPositionX = lastPos.x;
    176                     lastPositionY = lastPos.y;
    177                     lastPositionZ = lastPos.z;
    178                     totalPlayTime += (long) (Time.timeSinceLevelLoad - Entity.CreationTimeSinceLevelLoad);
    179                 } catch (NullReferenceException) {
    180                     Log.Out ("Entity not available. Something seems to be wrong here...");
    181                 }
    182 
    183                 clientInfo = null;
    184             }
    185         }
    186 
    187         public void SetOnline (ClientInfo ci) {
    188             Log.Out ("Player set to online: " + steamId);
    189             clientInfo = ci;
     40                public string Name {
     41                        get { return name == null ? string.Empty : name; }
     42                }
     43
     44                public string IP {
     45                        get { return ip == null ? string.Empty : ip; }
     46                }
     47
     48                public Inventory Inventory {
     49                        get {
     50                                if (inventory == null) {
     51                                        inventory = new Inventory ();
     52                                }
     53
     54                                return inventory;
     55                        }
     56                }
     57
     58                public bool IsOnline {
     59                        get { return clientInfo != null; }
     60                }
     61
     62                public ClientInfo ClientInfo {
     63                        get { return clientInfo; }
     64                }
     65
     66                public EntityPlayer Entity {
     67                        get {
     68                                if (IsOnline) {
     69                                        return GameManager.Instance.World.Players.dict [clientInfo.entityId];
     70                                }
     71
     72                                return null;
     73                        }
     74                }
     75
     76                public long TotalPlayTime {
     77                        get {
     78                                if (IsOnline) {
     79                                        return totalPlayTime + (long) (DateTime.Now - lastOnline).TotalSeconds;
     80                                }
     81
     82                                return totalPlayTime;
     83                        }
     84                }
     85
     86                public DateTime LastOnline {
     87                        get {
     88                                if (IsOnline) {
     89                                        return DateTime.Now;
     90                                }
     91
     92                                return lastOnline;
     93                        }
     94                }
     95
     96                public Vector3i LastPosition {
     97                        get {
     98                                if (IsOnline) {
     99                                        return new Vector3i (Entity.GetPosition ());
     100                                }
     101
     102                                return new Vector3i (lastPositionX, lastPositionY, lastPositionZ);
     103                        }
     104                }
     105
     106                public bool LandProtectionActive {
     107                        get {
     108                                return GameManager.Instance.World.IsLandProtectionValidForPlayer (GameManager.Instance
     109                                        .GetPersistentPlayerList ().GetPlayerData (SteamID));
     110                        }
     111                }
     112
     113                public float LandProtectionMultiplier {
     114                        get {
     115                                return GameManager.Instance.World.GetLandProtectionHardnessModifierForPlayer (GameManager.Instance
     116                                        .GetPersistentPlayerList ().GetPlayerData (SteamID));
     117                        }
     118                }
     119
     120
     121                [Obsolete ("Experience no longer available, use Level instead")]
     122                public uint Experience {
     123                        get { return 0; }
     124                }
     125
     126                public float Level {
     127                        get {
     128                                float expForNextLevel =
     129                                        (int) Math.Min (Progression.BaseExpToLevel * Mathf.Pow (Progression.ExpMultiplier, level + 1),
     130                                                int.MaxValue);
     131                                float fLevel = level + 1f - expToNextLevel / expForNextLevel;
     132                                return fLevel;
     133                        }
     134                }
     135
     136                public bool IsChatMuted {
     137                        get { return chatMuted; }
     138                        set { chatMuted = value; }
     139                }
     140
     141                public int MaxChatLength {
     142                        get {
     143                                if (maxChatLength == 0) {
     144                                        maxChatLength = 255;
     145                                }
     146
     147                                return maxChatLength;
     148                        }
     149                        set { maxChatLength = value; }
     150                }
     151
     152                public string ChatColor {
     153                        get {
     154                                if (chatColor == null || chatColor == "") {
     155                                        chatColor = "";
     156                                }
     157
     158                                return chatColor;
     159                        }
     160
     161                        set { chatColor = value; }
     162                }
     163
     164                public bool ChatName {
     165                        get { return chatName; }
     166
     167                        set { chatName = value; }
     168                }
     169
     170                public Player (string steamId) {
     171                        this.steamId = steamId;
     172                        inventory = new Inventory ();
     173                }
     174
     175                public void SetOffline () {
     176                        if (clientInfo != null) {
     177                                Log.Out ("Player set to offline: " + steamId);
     178                                lastOnline = DateTime.Now;
     179                                try {
     180                                        Vector3i lastPos = new Vector3i (Entity.GetPosition ());
     181                                        lastPositionX = lastPos.x;
     182                                        lastPositionY = lastPos.y;
     183                                        lastPositionZ = lastPos.z;
     184                                        totalPlayTime += (long) (Time.timeSinceLevelLoad - Entity.CreationTimeSinceLevelLoad);
     185                                } catch (NullReferenceException) {
     186                                        Log.Out ("Entity not available. Something seems to be wrong here...");
     187                                }
     188
     189                                clientInfo = null;
     190                        }
     191                }
     192
     193                public void SetOnline (ClientInfo ci) {
     194                        Log.Out ("Player set to online: " + steamId);
     195                        clientInfo = ci;
    190196            entityId = ci.entityId;
    191             name = ci.playerName;
    192             ip = ci.ip;
    193             lastOnline = DateTime.Now;
    194         }
    195 
    196         public void Update (PlayerDataFile _pdf) {
    197             UpdateProgression (_pdf);
    198             inventory.Update (_pdf);
    199         }
    200 
    201         private void UpdateProgression (PlayerDataFile _pdf) {
    202             if (_pdf.progressionData.Length > 0) {
    203                 using (PooledBinaryReader pbr = MemoryPools.poolBinaryReader.AllocSync (false)) {
    204                     pbr.SetBaseStream (_pdf.progressionData);
    205                     Progression p = Progression.Read (pbr, null);
    206                     expToNextLevel = (uint) p.ExpToNextLevel;
    207                     level = p.Level;
    208                 }
    209             }
    210         }
    211 
    212         public Player (string steamId) {
    213             this.steamId = steamId;
    214             this.inventory = new Inventory ();
    215         }
    216     }
     197                        name = ci.playerName;
     198                        ip = ci.ip;
     199                        lastOnline = DateTime.Now;
     200                }
     201
     202                public void Update (PlayerDataFile _pdf) {
     203                        UpdateProgression (_pdf);
     204                        inventory.Update (_pdf);
     205                }
     206
     207                private void UpdateProgression (PlayerDataFile _pdf) {
     208                        if (_pdf.progressionData.Length > 0) {
     209                                using (PooledBinaryReader pbr = MemoryPools.poolBinaryReader.AllocSync (false)) {
     210                                        pbr.SetBaseStream (_pdf.progressionData);
     211                                        Progression p = Progression.Read (pbr, null);
     212                                        expToNextLevel = (uint) p.ExpToNextLevel;
     213                                        level = p.Level;
     214                                }
     215                        }
     216                }
     217        }
    217218}
Note: See TracChangeset for help on using the changeset viewer.