Ignore:
Timestamp:
Jan 19, 2019, 6:12:21 PM (6 years ago)
Author:
alloc
Message:

Fixed game version compatibility of GamePrefs
Code style cleanup (mostly argument names)

Location:
binary-improvements/MapRendering
Files:
29 edited

Legend:

Unmodified
Added
Removed

  • binary-improvements/MapRendering/API.cs

    r337 r351  
    2121
    2222                private void GameShutdown () {
    23                         AllocsFixes.MapRendering.MapRendering.Shutdown ();
     23                        MapRendering.MapRendering.Shutdown ();
    2424                }
    2525
    2626                private void CalcChunkColorsDone (Chunk _chunk) {
    27                         AllocsFixes.MapRendering.MapRendering.RenderSingleChunk (_chunk);
     27                        MapRendering.MapRendering.RenderSingleChunk (_chunk);
    2828                }
    2929        }

  • binary-improvements/MapRendering/MapRendering/Constants.cs

    r331 r351  
    33namespace AllocsFixes.MapRendering {
    44        public class Constants {
    5                 public static TextureFormat DEFAULT_TEX_FORMAT = TextureFormat.ARGB32;
     5                public static readonly TextureFormat DEFAULT_TEX_FORMAT = TextureFormat.ARGB32;
    66                public static int MAP_BLOCK_SIZE = 128;
    7                 public static int MAP_CHUNK_SIZE = 16;
    8                 public static int MAP_REGION_SIZE = 512;
     7                public const int MAP_CHUNK_SIZE = 16;
     8                public const int MAP_REGION_SIZE = 512;
    99                public static int ZOOMLEVELS = 5;
    1010                public static string MAP_DIRECTORY = string.Empty;

  • binary-improvements/MapRendering/MapRendering/MapRenderBlockBuffer.cs

    r346 r351  
    1818                private string currentBlockMapFolder = string.Empty;
    1919
    20                 public MapRenderBlockBuffer (int level, MapTileCache cache) {
    21                         zoomLevel = level;
    22                         this.cache = cache;
     20                public MapRenderBlockBuffer (int _level, MapTileCache _cache) {
     21                        zoomLevel = _level;
     22                        cache = _cache;
    2323                        folderBase = Constants.MAP_DIRECTORY + "/" + zoomLevel + "/";
    2424
    … …  
    5959                }
    6060
    61                 public bool LoadBlock (Vector2i block) {
     61                public bool LoadBlock (Vector2i _block) {
    6262                        Profiler.BeginSample ("LoadBlock");
    6363                        lock (blockMap) {
    64                                 if (currentBlockMapPos != block) {
     64                                if (currentBlockMapPos != _block) {
    6565                                        Profiler.BeginSample ("LoadBlock.Strings");
    6666                                        string folder;
    67                                         if (currentBlockMapPos.x != block.x) {
    68                                                 folder = folderBase + block.x + '/';
     67                                        if (currentBlockMapPos.x != _block.x) {
     68                                                folder = folderBase + _block.x + '/';
    6969
    7070                                                Profiler.BeginSample ("LoadBlock.Directory");
    … …  
    7575                                        }
    7676
    77                                         string fileName = folder + block.y + ".png";
     77                                        string fileName = folder + _block.y + ".png";
    7878                                        Profiler.EndSample ();
    7979                                       
    … …  
    8282
    8383                                        currentBlockMapFolder = folder;
    84                                         currentBlockMapPos = block;
     84                                        currentBlockMapPos = _block;
    8585
    8686                                        Profiler.EndSample ();
    … …  
    9393                }
    9494
    95                 public void SetPart (Vector2i offset, int partSize, Color32[] pixels) {
    96                         if (offset.x + partSize > Constants.MAP_BLOCK_SIZE || offset.y + partSize > Constants.MAP_BLOCK_SIZE) {
     95                public void SetPart (Vector2i _offset, int _partSize, Color32[] _pixels) {
     96                        if (_offset.x + _partSize > Constants.MAP_BLOCK_SIZE || _offset.y + _partSize > Constants.MAP_BLOCK_SIZE) {
    9797                                Log.Error (string.Format ("MapBlockBuffer[{0}].SetPart ({1}, {2}, {3}) has blockMap.size ({4}/{5})",
    98                                         zoomLevel, offset, partSize, pixels.Length, Constants.MAP_BLOCK_SIZE, Constants.MAP_BLOCK_SIZE));
     98                                        zoomLevel, _offset, _partSize, _pixels.Length, Constants.MAP_BLOCK_SIZE, Constants.MAP_BLOCK_SIZE));
    9999                                return;
    100100                        }
    101101
    102102                        Profiler.BeginSample ("SetPart");
    103                         blockMap.SetPixels32 (offset.x, offset.y, partSize, partSize, pixels);
     103                        blockMap.SetPixels32 (_offset.x, _offset.y, _partSize, _partSize, _pixels);
    104104                        Profiler.EndSample ();
    105105                }
    … …  
    135135                }
    136136
    137                 public void SetPartNative (Vector2i offset, int partSize, NativeArray<int> pixels) {
    138                         if (offset.x + partSize > Constants.MAP_BLOCK_SIZE || offset.y + partSize > Constants.MAP_BLOCK_SIZE) {
     137                public void SetPartNative (Vector2i _offset, int _partSize, NativeArray<int> _pixels) {
     138                        if (_offset.x + _partSize > Constants.MAP_BLOCK_SIZE || _offset.y + _partSize > Constants.MAP_BLOCK_SIZE) {
    139139                                Log.Error (string.Format ("MapBlockBuffer[{0}].SetPart ({1}, {2}, {3}) has blockMap.size ({4}/{5})",
    140                                         zoomLevel, offset, partSize, pixels.Length, Constants.MAP_BLOCK_SIZE, Constants.MAP_BLOCK_SIZE));
     140                                        zoomLevel, _offset, _partSize, _pixels.Length, Constants.MAP_BLOCK_SIZE, Constants.MAP_BLOCK_SIZE));
    141141                                return;
    142142                        }
    … …  
    145145                        NativeArray<int> destData = blockMap.GetRawTextureData<int> ();
    146146                       
    147                         for (int y = 0; y < partSize; y++) {
    148                                 int srcLineStartIdx = partSize * y;
    149                                 int destLineStartIdx = blockMap.width * (offset.y + y) + offset.x;
    150                                 for (int x = 0; x < partSize; x++) {
    151                                         destData [destLineStartIdx + x] = pixels [srcLineStartIdx + x];
     147                        for (int y = 0; y < _partSize; y++) {
     148                                int srcLineStartIdx = _partSize * y;
     149                                int destLineStartIdx = blockMap.width * (_offset.y + y) + _offset.x;
     150                                for (int x = 0; x < _partSize; x++) {
     151                                        destData [destLineStartIdx + x] = _pixels [srcLineStartIdx + x];
    152152                                }
    153153                        }

  • binary-improvements/MapRendering/MapRendering/MapRendering.cs

    r346 r351  
    55using System.Text;
    66using System.Threading;
    7 using System.Timers;
    87using AllocsFixes.FileCache;
    98using AllocsFixes.JSON;
    … …  
    6665                }
    6766
    68                 public static void RenderSingleChunk (Chunk chunk) {
     67                public static void RenderSingleChunk (Chunk _chunk) {
    6968                        if (renderingEnabled) {
    7069                                // TODO: Replace with regular thread and a blocking queue / set
    71                                 ThreadPool.UnsafeQueueUserWorkItem (o => {
     70                                ThreadPool.UnsafeQueueUserWorkItem (_o => {
    7271                                        try {
    7372                                                if (!Instance.renderingFullMap) {
    7473                                                        lock (lockObject) {
    75                                                                 Chunk c = (Chunk) o;
     74                                                                Chunk c = (Chunk) _o;
    7675                                                                Vector3i cPos = c.GetWorldPos ();
    7776                                                                Vector2i cPos2 = new Vector2i (cPos.x / Constants.MAP_CHUNK_SIZE,
    … …  
    9594                                                Log.Out ("Exception in MapRendering.RenderSingleChunk(): " + e);
    9695                                        }
    97                                 }, chunk);
     96                                }, _chunk);
    9897                        }
    9998                }
    … …  
    279278                }
    280279
    281                 private void RenderZoomLevel (Vector2i innerBlock) {
     280                private void RenderZoomLevel (Vector2i _innerBlock) {
    282281                        Profiler.BeginSample ("RenderZoomLevel");
    283282                        int level = Constants.ZOOMLEVELS - 1;
    284283                        while (level > 0) {
    285284                                Vector2i block, blockOffset;
    286                                 getBlockNumber (innerBlock, out block, out blockOffset, 2, Constants.MAP_BLOCK_SIZE / 2);
     285                                getBlockNumber (_innerBlock, out block, out blockOffset, 2, Constants.MAP_BLOCK_SIZE / 2);
    287286
    288287                                zoomLevelBuffers [level - 1].LoadBlock (block);
    … …  
    299298
    300299                                level--;
    301                                 innerBlock = block;
     300                                _innerBlock = block;
    302301                        }
    303302                        Profiler.EndSample ();
    304303                }
    305304
    306                 private void getBlockNumber (Vector2i innerPos, out Vector2i block, out Vector2i blockOffset, int scaleFactor,
    307                         int offsetSize) {
    308                         block = default (Vector2i);
    309                         blockOffset = default (Vector2i);
    310                         block.x = (innerPos.x + 16777216) / scaleFactor - 16777216 / scaleFactor;
    311                         block.y = (innerPos.y + 16777216) / scaleFactor - 16777216 / scaleFactor;
    312                         blockOffset.x = (innerPos.x + 16777216) % scaleFactor * offsetSize;
    313                         blockOffset.y = (innerPos.y + 16777216) % scaleFactor * offsetSize;
     305                private void getBlockNumber (Vector2i _innerPos, out Vector2i _block, out Vector2i _blockOffset, int _scaleFactor,
     306                        int _offsetSize) {
     307                        _block = default (Vector2i);
     308                        _blockOffset = default (Vector2i);
     309                        _block.x = (_innerPos.x + 16777216) / _scaleFactor - 16777216 / _scaleFactor;
     310                        _block.y = (_innerPos.y + 16777216) / _scaleFactor - 16777216 / _scaleFactor;
     311                        _blockOffset.x = (_innerPos.x + 16777216) % _scaleFactor * _offsetSize;
     312                        _blockOffset.y = (_innerPos.y + 16777216) % _scaleFactor * _offsetSize;
    314313                }
    315314
    … …  
    352351                }
    353352
    354                 private void getWorldExtent (RegionFileManager rfm, out Vector2i minChunk, out Vector2i maxChunk,
    355                         out Vector2i minPos, out Vector2i maxPos,
    356                         out int widthChunks, out int heightChunks,
    357                         out int widthPix, out int heightPix) {
    358                         minChunk = default (Vector2i);
    359                         maxChunk = default (Vector2i);
    360                         minPos = default (Vector2i);
    361                         maxPos = default (Vector2i);
    362 
    363                         long[] keys = rfm.GetAllChunkKeys ();
     353                private void getWorldExtent (RegionFileManager _rfm, out Vector2i _minChunk, out Vector2i _maxChunk,
     354                        out Vector2i _minPos, out Vector2i _maxPos,
     355                        out int _widthChunks, out int _heightChunks,
     356                        out int _widthPix, out int _heightPix) {
     357                        _minChunk = default (Vector2i);
     358                        _maxChunk = default (Vector2i);
     359                        _minPos = default (Vector2i);
     360                        _maxPos = default (Vector2i);
     361
     362                        long[] keys = _rfm.GetAllChunkKeys ();
    364363                        int minX = int.MaxValue;
    365364                        int minY = int.MaxValue;
    … …  
    387386                        }
    388387
    389                         minChunk.x = minX;
    390                         minChunk.y = minY;
    391 
    392                         maxChunk.x = maxX;
    393                         maxChunk.y = maxY;
    394 
    395                         minPos.x = minX * Constants.MAP_CHUNK_SIZE;
    396                         minPos.y = minY * Constants.MAP_CHUNK_SIZE;
    397 
    398                         maxPos.x = maxX * Constants.MAP_CHUNK_SIZE;
    399                         maxPos.y = maxY * Constants.MAP_CHUNK_SIZE;
    400 
    401                         widthChunks = maxX - minX + 1;
    402                         heightChunks = maxY - minY + 1;
    403 
    404                         widthPix = widthChunks * Constants.MAP_CHUNK_SIZE;
    405                         heightPix = heightChunks * Constants.MAP_CHUNK_SIZE;
    406                 }
    407 
    408                 private static Color32 shortColorToColor32 (ushort col) {
    409                         byte r = (byte) (256 * ((col >> 10) & 31) / 32);
    410                         byte g = (byte) (256 * ((col >> 5) & 31) / 32);
    411                         byte b = (byte) (256 * (col & 31) / 32);
    412                         byte a = 255;
     388                        _minChunk.x = minX;
     389                        _minChunk.y = minY;
     390
     391                        _maxChunk.x = maxX;
     392                        _maxChunk.y = maxY;
     393
     394                        _minPos.x = minX * Constants.MAP_CHUNK_SIZE;
     395                        _minPos.y = minY * Constants.MAP_CHUNK_SIZE;
     396
     397                        _maxPos.x = maxX * Constants.MAP_CHUNK_SIZE;
     398                        _maxPos.y = maxY * Constants.MAP_CHUNK_SIZE;
     399
     400                        _widthChunks = maxX - minX + 1;
     401                        _heightChunks = maxY - minY + 1;
     402
     403                        _widthPix = _widthChunks * Constants.MAP_CHUNK_SIZE;
     404                        _heightPix = _heightChunks * Constants.MAP_CHUNK_SIZE;
     405                }
     406
     407                private static Color32 shortColorToColor32 (ushort _col) {
     408                        byte r = (byte) (256 * ((_col >> 10) & 31) / 32);
     409                        byte g = (byte) (256 * ((_col >> 5) & 31) / 32);
     410                        byte b = (byte) (256 * (_col & 31) / 32);
     411                        const byte a = 255;
    413412                        return new Color32 (r, g, b, a);
    414413                }

  • binary-improvements/MapRendering/Web/API/ExecuteConsoleCommand.cs

    r347 r351  
    44namespace AllocsFixes.NetConnections.Servers.Web.API {
    55        public class ExecuteConsoleCommand : WebAPI {
    6                 public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user,
    7                         int permissionLevel) {
    8                         if (string.IsNullOrEmpty (req.QueryString ["command"])) {
    9                                 resp.StatusCode = (int) HttpStatusCode.BadRequest;
    10                                 Web.SetResponseTextContent (resp, "No command given");
     6                public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
     7                        int _permissionLevel) {
     8                        if (string.IsNullOrEmpty (_req.QueryString ["command"])) {
     9                                _resp.StatusCode = (int) HttpStatusCode.BadRequest;
     10                                Web.SetResponseTextContent (_resp, "No command given");
    1111                                return;
    1212                        }
    1313
    1414                        WebCommandResult.ResultType responseType =
    15                                 req.QueryString ["raw"] != null
     15                                _req.QueryString ["raw"] != null
    1616                                        ? WebCommandResult.ResultType.Raw
    17                                         : (req.QueryString ["simple"] != null
     17                                        : (_req.QueryString ["simple"] != null
    1818                                                ? WebCommandResult.ResultType.ResultOnly
    1919                                                : WebCommandResult.ResultType.Full);
    2020
    21                         string commandline = req.QueryString ["command"];
     21                        string commandline = _req.QueryString ["command"];
    2222                        string commandPart = commandline.Split (' ') [0];
    2323                        string argumentsPart = commandline.Substring (Math.Min (commandline.Length, commandPart.Length + 1));
    … …  
    2626
    2727                        if (command == null) {
    28                                 resp.StatusCode = (int) HttpStatusCode.NotFound;
    29                                 Web.SetResponseTextContent (resp, "Unknown command");
     28                                _resp.StatusCode = (int) HttpStatusCode.NotFound;
     29                                Web.SetResponseTextContent (_resp, "Unknown command");
    3030                                return;
    3131                        }
    … …  
    3434                                GameManager.Instance.adminTools.GetAdminToolsCommandPermission (command.GetCommands ());
    3535
    36                         if (permissionLevel > atcp.PermissionLevel) {
    37                                 resp.StatusCode = (int) HttpStatusCode.Forbidden;
    38                                 Web.SetResponseTextContent (resp, "You are not allowed to execute this command");
     36                        if (_permissionLevel > atcp.PermissionLevel) {
     37                                _resp.StatusCode = (int) HttpStatusCode.Forbidden;
     38                                Web.SetResponseTextContent (_resp, "You are not allowed to execute this command");
    3939                                return;
    4040                        }
    4141
    42                         resp.SendChunked = true;
    43                         WebCommandResult wcr = new WebCommandResult (commandPart, argumentsPart, responseType, resp);
     42                        _resp.SendChunked = true;
     43                        WebCommandResult wcr = new WebCommandResult (commandPart, argumentsPart, responseType, _resp);
    4444                        SdtdConsole.Instance.ExecuteAsync (commandline, wcr);
    4545                }

  • binary-improvements/MapRendering/Web/API/GetAllowedCommands.cs

    r325 r351  
    44namespace AllocsFixes.NetConnections.Servers.Web.API {
    55        public class GetAllowedCommands : WebAPI {
    6                 public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user,
    7                         int permissionLevel) {
     6                public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
     7                        int _permissionLevel) {
    88                        JSONObject result = new JSONObject ();
    99                        JSONArray entries = new JSONArray ();
    … …  
    1111                                AdminToolsCommandPermissions atcp =
    1212                                        GameManager.Instance.adminTools.GetAdminToolsCommandPermission (cc.GetCommands ());
    13                                 if (permissionLevel <= atcp.PermissionLevel) {
     13                                if (_permissionLevel <= atcp.PermissionLevel) {
    1414                                        string cmd = string.Empty;
    1515                                        foreach (string s in cc.GetCommands ()) {
    … …  
    2929                        result.Add ("commands", entries);
    3030
    31                         WriteJSON (resp, result);
     31                        WriteJSON (_resp, result);
    3232                }
    3333

  • binary-improvements/MapRendering/Web/API/GetAnimalsLocation.cs

    r325 r351  
    88                private readonly List<EntityAnimal> animals = new List<EntityAnimal> ();
    99
    10                 public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user,
    11                         int permissionLevel) {
     10                public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
     11                        int _permissionLevel) {
    1212                        JSONArray animalsJsResult = new JSONArray ();
    1313
    … …  
    3636                        }
    3737
    38                         WriteJSON (resp, animalsJsResult);
     38                        WriteJSON (_resp, animalsJsResult);
    3939                }
    4040        }

  • binary-improvements/MapRendering/Web/API/GetHostileLocation.cs

    r325 r351  
    88                private readonly List<EntityEnemy> enemies = new List<EntityEnemy> ();
    99
    10                 public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user,
    11                         int permissionLevel) {
     10                public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
     11                        int _permissionLevel) {
    1212                        JSONArray hostilesJsResult = new JSONArray ();
    1313
    … …  
    3636                        }
    3737
    38                         WriteJSON (resp, hostilesJsResult);
     38                        WriteJSON (_resp, hostilesJsResult);
    3939                }
    4040        }

  • binary-improvements/MapRendering/Web/API/GetLandClaims.cs

    r332 r351  
    66namespace AllocsFixes.NetConnections.Servers.Web.API {
    77        public class GetLandClaims : WebAPI {
    8                 public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user,
    9                         int permissionLevel) {
     8                public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
     9                        int _permissionLevel) {
    1010                        string requestedSteamID = string.Empty;
    1111
    12                         if (req.QueryString ["steamid"] != null) {
     12                        if (_req.QueryString ["steamid"] != null) {
    1313                                ulong lViewersSteamID;
    14                                 requestedSteamID = req.QueryString ["steamid"];
     14                                requestedSteamID = _req.QueryString ["steamid"];
    1515                                if (requestedSteamID.Length != 17 || !ulong.TryParse (requestedSteamID, out lViewersSteamID)) {
    16                                         resp.StatusCode = (int) HttpStatusCode.BadRequest;
    17                                         Web.SetResponseTextContent (resp, "Invalid SteamID given");
     16                                        _resp.StatusCode = (int) HttpStatusCode.BadRequest;
     17                                        Web.SetResponseTextContent (_resp, "Invalid SteamID given");
    1818                                        return;
    1919                                }
    … …  
    2121
    2222                        // default user, cheap way to avoid 'null reference exception'
    23                         user = user ?? new WebConnection ("", IPAddress.None, 0L);
     23                        _user = _user ?? new WebConnection ("", IPAddress.None, 0L);
    2424
    25                         bool bViewAll = WebConnection.CanViewAllClaims (permissionLevel);
     25                        bool bViewAll = WebConnection.CanViewAllClaims (_permissionLevel);
    2626
    2727                        JSONObject result = new JSONObject ();
    28                         result.Add ("claimsize", new JSONNumber (GamePrefs.GetInt (EnumGamePrefs.LandClaimSize)));
     28                        result.Add ("claimsize", new JSONNumber (GamePrefs.GetInt (EnumUtils.Parse<EnumGamePrefs> ("LandClaimSize"))));
    2929
    3030                        JSONArray claimOwners = new JSONArray ();
    … …  
    3535                                if (!string.IsNullOrEmpty (requestedSteamID) && !bViewAll) {
    3636                                        ownerFilters = new[] {
    37                                                 LandClaimList.SteamIdFilter (user.SteamID.ToString ()),
     37                                                LandClaimList.SteamIdFilter (_user.SteamID.ToString ()),
    3838                                                LandClaimList.SteamIdFilter (requestedSteamID)
    3939                                        };
    4040                                } else if (!bViewAll) {
    41                                         ownerFilters = new[] {LandClaimList.SteamIdFilter (user.SteamID.ToString ())};
     41                                        ownerFilters = new[] {LandClaimList.SteamIdFilter (_user.SteamID.ToString ())};
    4242                                } else {
    4343                                        ownerFilters = new[] {LandClaimList.SteamIdFilter (requestedSteamID)};
    … …  
    7878                        }
    7979
    80                         WriteJSON (resp, result);
     80                        WriteJSON (_resp, result);
    8181                }
    8282        }

  • binary-improvements/MapRendering/Web/API/GetPlayerList.cs

    r332 r351  
    1717#endif
    1818
    19                 public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user,
    20                         int permissionLevel) {
     19                public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
     20                        int _permissionLevel) {
    2121                        AdminTools admTools = GameManager.Instance.adminTools;
    22                         user = user ?? new WebConnection ("", IPAddress.None, 0L);
    23 
    24                         bool bViewAll = WebConnection.CanViewAllPlayers (permissionLevel);
     22                        _user = _user ?? new WebConnection ("", IPAddress.None, 0L);
     23
     24                        bool bViewAll = WebConnection.CanViewAllPlayers (_permissionLevel);
    2525
    2626                        // TODO: Sort (and filter?) prior to converting to JSON ... hard as how to get the correct column's data? (i.e. column name matches JSON object field names, not source data)
    2727
    2828                        int rowsPerPage = 25;
    29                         if (req.QueryString ["rowsperpage"] != null) {
    30                                 int.TryParse (req.QueryString ["rowsperpage"], out rowsPerPage);
     29                        if (_req.QueryString ["rowsperpage"] != null) {
     30                                int.TryParse (_req.QueryString ["rowsperpage"], out rowsPerPage);
    3131                        }
    3232
    3333                        int page = 0;
    34                         if (req.QueryString ["page"] != null) {
    35                                 int.TryParse (req.QueryString ["page"], out page);
     34                        if (_req.QueryString ["page"] != null) {
     35                                int.TryParse (_req.QueryString ["page"], out page);
    3636                        }
    3737
    … …  
    5555                                }
    5656
    57                                 if (player_steam_ID == user.SteamID || bViewAll) {
     57                                if (player_steam_ID == _user.SteamID || bViewAll) {
    5858                                        JSONObject pos = new JSONObject ();
    5959                                        pos.Add ("x", new JSONNumber (p.LastPosition.x));
    … …  
    9393                        IEnumerable<JSONObject> list = playerList;
    9494
    95                         foreach (string key in req.QueryString.AllKeys) {
     95                        foreach (string key in _req.QueryString.AllKeys) {
    9696                                if (!string.IsNullOrEmpty (key) && key.StartsWith ("filter[")) {
    9797                                        string filterCol = key.Substring (key.IndexOf ('[') + 1);
    9898                                        filterCol = filterCol.Substring (0, filterCol.Length - 1);
    99                                         string filterVal = req.QueryString.Get (key).Trim ();
     99                                        string filterVal = _req.QueryString.Get (key).Trim ();
    100100
    101101                                        list = ExecuteFilter (list, filterCol, filterVal);
    … …  
    105105                        int totalAfterFilter = list.Count ();
    106106
    107                         foreach (string key in req.QueryString.AllKeys) {
     107                        foreach (string key in _req.QueryString.AllKeys) {
    108108                                if (!string.IsNullOrEmpty (key) && key.StartsWith ("sort[")) {
    109109                                        string sortCol = key.Substring (key.IndexOf ('[') + 1);
    110110                                        sortCol = sortCol.Substring (0, sortCol.Length - 1);
    111                                         string sortVal = req.QueryString.Get (key);
     111                                        string sortVal = _req.QueryString.Get (key);
    112112
    113113                                        list = ExecuteSort (list, sortCol, sortVal == "0");
    … …  
    130130                        result.Add ("players", playersJsResult);
    131131
    132                         WriteJSON (resp, result);
     132                        WriteJSON (_resp, result);
    133133                }
    134134
    135135                private IEnumerable<JSONObject> ExecuteFilter (IEnumerable<JSONObject> _list, string _filterCol,
    136136                        string _filterVal) {
    137                         if (_list.Count () == 0) {
     137                        if (!_list.Any()) {
    138138                                return _list;
    139139                        }
    … …  
    147147                                if (colType == typeof (JSONBoolean)) {
    148148                                        bool value = StringParsers.ParseBool (_filterVal);
    149                                         return _list.Where (line => ((JSONBoolean) line [_filterCol]).GetBool () == value);
     149                                        return _list.Where (_line => ((JSONBoolean) _line [_filterCol]).GetBool () == value);
    150150                                }
    151151
    … …  
    157157                                        //Log.Out ("GetPlayerList: Filter on String with Regex '" + _filterVal + "'");
    158158                                        Regex matcher = new Regex (_filterVal, RegexOptions.IgnoreCase);
    159                                         return _list.Where (line => matcher.IsMatch (((JSONString) line [_filterCol]).GetString ()));
     159                                        return _list.Where (_line => matcher.IsMatch (((JSONString) _line [_filterCol]).GetString ()));
    160160                                }
    161161                        }
    … …  
    198198                                }
    199199
    200                                 return _list.Where (delegate (JSONObject line) {
    201                                         double objVal = ((JSONNumber) line [_filterCol]).GetDouble ();
     200                                return _list.Where (delegate (JSONObject _line) {
     201                                        double objVal = ((JSONNumber) _line [_filterCol]).GetDouble ();
    202202                                        switch (matchType) {
    203203                                                case NumberMatchType.Greater:
    … …  
    230230                                if (colType == typeof (JSONNumber)) {
    231231                                        if (_ascending) {
    232                                                 return _list.OrderBy (line => ((JSONNumber) line [_sortCol]).GetDouble ());
    233                                         }
    234 
    235                                         return _list.OrderByDescending (line => ((JSONNumber) line [_sortCol]).GetDouble ());
     232                                                return _list.OrderBy (_line => ((JSONNumber) _line [_sortCol]).GetDouble ());
     233                                        }
     234
     235                                        return _list.OrderByDescending (_line => ((JSONNumber) _line [_sortCol]).GetDouble ());
    236236                                }
    237237
    238238                                if (colType == typeof (JSONBoolean)) {
    239239                                        if (_ascending) {
    240                                                 return _list.OrderBy (line => ((JSONBoolean) line [_sortCol]).GetBool ());
    241                                         }
    242 
    243                                         return _list.OrderByDescending (line => ((JSONBoolean) line [_sortCol]).GetBool ());
     240                                                return _list.OrderBy (_line => ((JSONBoolean) _line [_sortCol]).GetBool ());
     241                                        }
     242
     243                                        return _list.OrderByDescending (_line => ((JSONBoolean) _line [_sortCol]).GetBool ());
    244244                                }
    245245
    246246                                if (_ascending) {
    247                                         return _list.OrderBy (line => line [_sortCol].ToString ());
    248                                 }
    249 
    250                                 return _list.OrderByDescending (line => line [_sortCol].ToString ());
     247                                        return _list.OrderBy (_line => _line [_sortCol].ToString ());
     248                                }
     249
     250                                return _list.OrderByDescending (_line => _line [_sortCol].ToString ());
    251251                        }
    252252
    … …  
    255255
    256256
    257                 private bool NearlyEqual (double a, double b, double epsilon) {
    258                         double absA = Math.Abs (a);
    259                         double absB = Math.Abs (b);
    260                         double diff = Math.Abs (a - b);
    261 
    262                         if (a == b) {
     257                private bool NearlyEqual (double _a, double _b, double _epsilon) {
     258                        double absA = Math.Abs (_a);
     259                        double absB = Math.Abs (_b);
     260                        double diff = Math.Abs (_a - _b);
     261
     262                        if (_a == _b) {
    263263                                return true;
    264264                        }
    265265
    266                         if (a == 0 || b == 0 || diff < double.Epsilon) {
    267                                 return diff < epsilon;
    268                         }
    269 
    270                         return diff / (absA + absB) < epsilon;
     266                        if (_a == 0 || _b == 0 || diff < double.Epsilon) {
     267                                return diff < _epsilon;
     268                        }
     269
     270                        return diff / (absA + absB) < _epsilon;
    271271                }
    272272

  • binary-improvements/MapRendering/Web/API/GetPlayersLocation.cs

    r332 r351  
    66namespace AllocsFixes.NetConnections.Servers.Web.API {
    77        public class GetPlayersLocation : WebAPI {
    8                 public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user,
    9                         int permissionLevel) {
     8                public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
     9                        int _permissionLevel) {
    1010                        AdminTools admTools = GameManager.Instance.adminTools;
    11                         user = user ?? new WebConnection ("", IPAddress.None, 0L);
     11                        _user = _user ?? new WebConnection ("", IPAddress.None, 0L);
    1212
    1313                        bool listOffline = false;
    14                         if (req.QueryString ["offline"] != null) {
    15                                 bool.TryParse (req.QueryString ["offline"], out listOffline);
     14                        if (_req.QueryString ["offline"] != null) {
     15                                bool.TryParse (_req.QueryString ["offline"], out listOffline);
    1616                        }
    1717
    18                         bool bViewAll = WebConnection.CanViewAllPlayers (permissionLevel);
     18                        bool bViewAll = WebConnection.CanViewAllPlayers (_permissionLevel);
    1919
    2020                        JSONArray playersJsResult = new JSONArray ();
    … …  
    3737                                        }
    3838
    39                                         if (player_steam_ID == user.SteamID || bViewAll) {
     39                                        if (player_steam_ID == _user.SteamID || bViewAll) {
    4040                                                JSONObject pos = new JSONObject ();
    4141                                                pos.Add ("x", new JSONNumber (p.LastPosition.x));
    … …  
    6161                        }
    6262
    63                         WriteJSON (resp, playersJsResult);
     63                        WriteJSON (_resp, playersJsResult);
    6464                }
    6565        }

  • binary-improvements/MapRendering/Web/API/GetPlayersOnline.cs

    r326 r351  
    66namespace AllocsFixes.NetConnections.Servers.Web.API {
    77        public class GetPlayersOnline : WebAPI {
    8                 public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user,
    9                         int permissionLevel) {
     8                public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
     9                        int _permissionLevel) {
    1010                        JSONArray players = new JSONArray ();
    1111
    … …  
    4646                        }
    4747
    48                         WriteJSON (resp, players);
     48                        WriteJSON (_resp, players);
    4949                }
    5050        }

  • binary-improvements/MapRendering/Web/API/GetServerInfo.cs

    r325 r351  
    55namespace AllocsFixes.NetConnections.Servers.Web.API {
    66        public class GetServerInfo : WebAPI {
    7                 public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user,
    8                         int permissionLevel) {
     7                public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
     8                        int _permissionLevel) {
    99                        JSONObject serverInfo = new JSONObject ();
    1010
    … …  
    4242
    4343
    44                         WriteJSON (resp, serverInfo);
     44                        WriteJSON (_resp, serverInfo);
    4545                }
    4646        }

  • binary-improvements/MapRendering/Web/API/GetStats.cs

    r325 r351  
    55namespace AllocsFixes.NetConnections.Servers.Web.API {
    66        public class GetStats : WebAPI {
    7                 public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user,
    8                         int permissionLevel) {
     7                public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
     8                        int _permissionLevel) {
    99                        JSONObject result = new JSONObject ();
    1010
    … …  
    1919                        result.Add ("animals", new JSONNumber (Animals.Instance.GetCount ()));
    2020
    21                         WriteJSON (resp, result);
     21                        WriteJSON (_resp, result);
    2222                }
    2323

  • binary-improvements/MapRendering/Web/API/GetWebUIUpdates.cs

    r325 r351  
    55namespace AllocsFixes.NetConnections.Servers.Web.API {
    66        public class GetWebUIUpdates : WebAPI {
    7                 public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user,
    8                         int permissionLevel) {
     7                public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
     8                        int _permissionLevel) {
    99                        int latestLine;
    10                         if (req.QueryString ["latestLine"] == null ||
    11                             !int.TryParse (req.QueryString ["latestLine"], out latestLine)) {
     10                        if (_req.QueryString ["latestLine"] == null ||
     11                            !int.TryParse (_req.QueryString ["latestLine"], out latestLine)) {
    1212                                latestLine = 0;
    1313                        }
    … …  
    2727                        result.Add ("newlogs", new JSONNumber (LogBuffer.Instance.LatestLine - latestLine));
    2828
    29                         WriteJSON (resp, result);
     29                        WriteJSON (_resp, result);
    3030                }
    3131

  • binary-improvements/MapRendering/Web/API/Null.cs

    r325 r351  
    44namespace AllocsFixes.NetConnections.Servers.Web.API {
    55        public class Null : WebAPI {
    6                 public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user,
    7                         int permissionLevel) {
    8                         resp.ContentLength64 = 0;
    9                         resp.ContentType = "text/plain";
    10                         resp.ContentEncoding = Encoding.ASCII;
    11                         resp.OutputStream.Write (new byte[] { }, 0, 0);
     6                public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
     7                        int _permissionLevel) {
     8                        _resp.ContentLength64 = 0;
     9                        _resp.ContentType = "text/plain";
     10                        _resp.ContentEncoding = Encoding.ASCII;
     11                        _resp.OutputStream.Write (new byte[] { }, 0, 0);
    1212                }
    1313        }

  • binary-improvements/MapRendering/Web/API/WebAPI.cs

    r332 r351  
    1717#endif
    1818
    19                 public static void WriteJSON (HttpListenerResponse resp, JSONNode root) {
     19                public static void WriteJSON (HttpListenerResponse _resp, JSONNode _root) {
    2020#if ENABLE_PROFILER
    2121                        jsonSerializeSampler.Begin ();
    2222#endif
    2323                        StringBuilder sb = new StringBuilder ();
    24                         root.ToString (sb);
     24                        _root.ToString (sb);
    2525#if ENABLE_PROFILER
    2626                        jsonSerializeSampler.End ();
    … …  
    2828#endif
    2929                        byte[] buf = Encoding.UTF8.GetBytes (sb.ToString ());
    30                         resp.ContentLength64 = buf.Length;
    31                         resp.ContentType = "application/json";
    32                         resp.ContentEncoding = Encoding.UTF8;
    33                         resp.OutputStream.Write (buf, 0, buf.Length);
     30                        _resp.ContentLength64 = buf.Length;
     31                        _resp.ContentType = "application/json";
     32                        _resp.ContentEncoding = Encoding.UTF8;
     33                        _resp.OutputStream.Write (buf, 0, buf.Length);
    3434#if ENABLE_PROFILER
    3535                        netWriteSampler.End ();
    … …  
    4545                }
    4646
    47                 public abstract void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user,
    48                         int permissionLevel);
     47                public abstract void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
     48                        int _permissionLevel);
    4949
    5050                public virtual int DefaultPermissionLevel () {

  • binary-improvements/MapRendering/Web/ConnectionHandler.cs

    r332 r351  
    4141                }
    4242
    43                 public void SendLine (string line) {
     43                public void SendLine (string _line) {
    4444                        foreach (KeyValuePair<string, WebConnection> kvp in connections) {
    45                                 kvp.Value.SendLine (line);
     45                                kvp.Value.SendLine (_line);
    4646                        }
    4747                }

  • binary-improvements/MapRendering/Web/Handlers/ApiHandler.cs

    r332 r351  
    1111                private readonly string staticPart;
    1212
    13                 public ApiHandler (string staticPart, string moduleName = null) : base (moduleName) {
    14                         this.staticPart = staticPart;
     13                public ApiHandler (string _staticPart, string _moduleName = null) : base (_moduleName) {
     14                        staticPart = _staticPart;
    1515
    1616                        foreach (Type t in Assembly.GetExecutingAssembly ().GetTypes ()) {
    … …  
    4545#endif
    4646
    47                 public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user,
    48                         int permissionLevel) {
    49                         string apiName = req.Url.AbsolutePath.Remove (0, staticPart.Length);
    50                         if (!AuthorizeForCommand (apiName, user, permissionLevel)) {
    51                                 resp.StatusCode = (int) HttpStatusCode.Forbidden;
    52                                 if (user != null) {
     47                public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
     48                        int _permissionLevel) {
     49                        string apiName = _req.Url.AbsolutePath.Remove (0, staticPart.Length);
     50
     51                        WebAPI api;
     52                        if (!apis.TryGetValue (apiName, out api)) {
     53                                Log.Out ("Error in ApiHandler.HandleRequest(): No handler found for API \"" + apiName + "\"");
     54                                _resp.StatusCode = (int) HttpStatusCode.NotFound;
     55                                return;
     56                        }
     57
     58                        if (!AuthorizeForCommand (apiName, _user, _permissionLevel)) {
     59                                _resp.StatusCode = (int) HttpStatusCode.Forbidden;
     60                                if (_user != null) {
    5361                                        //Log.Out ("ApiHandler: user '{0}' not allowed to execute '{1}'", user.SteamID, apiName);
    5462                                }
    … …  
    5765                        }
    5866
    59                         WebAPI api;
    60                         if (apis.TryGetValue (apiName, out api)) {
    61                                 try {
     67                        try {
    6268#if ENABLE_PROFILER
    63                                         apiHandlerSampler.Begin ();
     69                                apiHandlerSampler.Begin ();
    6470#endif
    65                                         api.HandleRequest (req, resp, user, permissionLevel);
     71                                api.HandleRequest (_req, _resp, _user, _permissionLevel);
    6672#if ENABLE_PROFILER
    67                                         apiHandlerSampler.End ();
     73                                apiHandlerSampler.End ();
    6874#endif
    69                                         return;
    70                                 } catch (Exception e) {
    71                                         Log.Error ("Error in ApiHandler.HandleRequest(): Handler {0} threw an exception:", api.Name);
    72                                         Log.Exception (e);
    73                                         resp.StatusCode = (int) HttpStatusCode.InternalServerError;
    74                                         return;
    75                                 }
     75                        } catch (Exception e) {
     76                                Log.Error ("Error in ApiHandler.HandleRequest(): Handler {0} threw an exception:", api.Name);
     77                                Log.Exception (e);
     78                                _resp.StatusCode = (int) HttpStatusCode.InternalServerError;
    7679                        }
    77                        
    78                         Log.Out ("Error in ApiHandler.HandleRequest(): No handler found for API \"" + apiName + "\"");
    79                         resp.StatusCode = (int) HttpStatusCode.NotFound;
    8080                }
    8181
    82                 private bool AuthorizeForCommand (string apiName, WebConnection user, int permissionLevel) {
    83                         return WebPermissions.Instance.ModuleAllowedWithLevel ("webapi." + apiName, permissionLevel);
     82                private bool AuthorizeForCommand (string _apiName, WebConnection _user, int _permissionLevel) {
     83                        return WebPermissions.Instance.ModuleAllowedWithLevel ("webapi." + _apiName, _permissionLevel);
    8484                }
    8585        }

  • binary-improvements/MapRendering/Web/Handlers/ItemIconHandler.cs

    r326 r351  
    1818                }
    1919
    20                 public ItemIconHandler (string staticPart, bool logMissingFiles, string moduleName = null) : base (moduleName) {
    21                         this.staticPart = staticPart;
    22                         this.logMissingFiles = logMissingFiles;
     20                public ItemIconHandler (string _staticPart, bool _logMissingFiles, string _moduleName = null) : base (_moduleName) {
     21                        staticPart = _staticPart;
     22                        logMissingFiles = _logMissingFiles;
    2323                        Instance = this;
    2424                }
    … …  
    2626                public static ItemIconHandler Instance { get; private set; }
    2727
    28                 public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user,
    29                         int permissionLevel) {
     28                public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
     29                        int _permissionLevel) {
    3030                        if (!loaded) {
    31                                 resp.StatusCode = (int) HttpStatusCode.InternalServerError;
     31                                _resp.StatusCode = (int) HttpStatusCode.InternalServerError;
    3232                                Log.Out ("Web:IconHandler: Icons not loaded");
    3333                                return;
    3434                        }
    3535
    36                         string requestFileName = req.Url.AbsolutePath.Remove (0, staticPart.Length);
     36                        string requestFileName = _req.Url.AbsolutePath.Remove (0, staticPart.Length);
    3737                        requestFileName = requestFileName.Remove (requestFileName.LastIndexOf ('.'));
    3838
    39                         if (icons.ContainsKey (requestFileName) && req.Url.AbsolutePath.EndsWith (".png", StringComparison.OrdinalIgnoreCase)) {
    40                                 resp.ContentType = MimeType.GetMimeType (".png");
     39                        if (icons.ContainsKey (requestFileName) && _req.Url.AbsolutePath.EndsWith (".png", StringComparison.OrdinalIgnoreCase)) {
     40                                _resp.ContentType = MimeType.GetMimeType (".png");
    4141
    4242                                byte[] itemIconData = icons [requestFileName];
    4343
    44                                 resp.ContentLength64 = itemIconData.Length;
    45                                 resp.OutputStream.Write (itemIconData, 0, itemIconData.Length);
     44                                _resp.ContentLength64 = itemIconData.Length;
     45                                _resp.OutputStream.Write (itemIconData, 0, itemIconData.Length);
    4646                        } else {
    47                                 resp.StatusCode = (int) HttpStatusCode.NotFound;
     47                                _resp.StatusCode = (int) HttpStatusCode.NotFound;
    4848                                if (logMissingFiles) {
    49                                         Log.Out ("Web:IconHandler:FileNotFound: \"" + req.Url.AbsolutePath + "\" ");
     49                                        Log.Out ("Web:IconHandler:FileNotFound: \"" + _req.Url.AbsolutePath + "\" ");
    5050                                }
    5151                        }

  • binary-improvements/MapRendering/Web/Handlers/PathHandler.cs

    r325 r351  
    1414                }
    1515
    16                 public abstract void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user,
    17                         int permissionLevel);
     16                public abstract void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
     17                        int _permissionLevel);
    1818
    19                 public bool IsAuthorizedForHandler (WebConnection user, int permissionLevel) {
     19                public bool IsAuthorizedForHandler (WebConnection _user, int _permissionLevel) {
    2020                        if (moduleName != null) {
    21                                 return WebPermissions.Instance.ModuleAllowedWithLevel (moduleName, permissionLevel);
     21                                return WebPermissions.Instance.ModuleAllowedWithLevel (moduleName, _permissionLevel);
    2222                        }
    2323

  • binary-improvements/MapRendering/Web/Handlers/SessionHandler.cs

    r325 r351  
    1010                private readonly string staticPart;
    1111
    12                 public SessionHandler (string _staticPart, string _dataFolder, Web _parent, string moduleName = null) :
    13                         base (moduleName) {
     12                public SessionHandler (string _staticPart, string _dataFolder, Web _parent, string _moduleName = null) :
     13                        base (_moduleName) {
    1414                        staticPart = _staticPart;
    1515                        parent = _parent;
    … …  
    2424                }
    2525
    26                 public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user,
    27                         int permissionLevel) {
    28                         string subpath = req.Url.AbsolutePath.Remove (0, staticPart.Length);
     26                public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
     27                        int _permissionLevel) {
     28                        string subpath = _req.Url.AbsolutePath.Remove (0, staticPart.Length);
    2929
    3030                        StringBuilder result = new StringBuilder ();
    … …  
    3232
    3333                        if (subpath.StartsWith ("verify")) {
    34                                 if (user != null) {
    35                                         resp.Redirect ("/static/index.html");
     34                                if (_user != null) {
     35                                        _resp.Redirect ("/static/index.html");
    3636                                        return;
    3737                                }
    … …  
    4040                                        "<h1>Login failed, <a href=\"/static/index.html\">click to return to main page</a>.</h1>");
    4141                        } else if (subpath.StartsWith ("logout")) {
    42                                 if (user != null) {
    43                                         parent.connectionHandler.LogOut (user.SessionID);
     42                                if (_user != null) {
     43                                        parent.connectionHandler.LogOut (_user.SessionID);
    4444                                        Cookie cookie = new Cookie ("sid", "", "/");
    4545                                        cookie.Expired = true;
    46                                         resp.AppendCookie (cookie);
    47                                         resp.Redirect ("/static/index.html");
     46                                        _resp.AppendCookie (cookie);
     47                                        _resp.Redirect ("/static/index.html");
    4848                                        return;
    4949                                }
    … …  
    5252                                        "<h1>Not logged in, <a href=\"/static/index.html\">click to return to main page</a>.</h1>");
    5353                        } else if (subpath.StartsWith ("login")) {
    54                                 string host = (Web.isSslRedirected (req) ? "https://" : "http://") + req.UserHostName;
     54                                string host = (Web.isSslRedirected (_req) ? "https://" : "http://") + _req.UserHostName;
    5555                                string url = OpenID.GetOpenIdLoginUrl (host, host + "/session/verify");
    56                                 resp.Redirect (url);
     56                                _resp.Redirect (url);
    5757                                return;
    5858                        } else {
    … …  
    6363                        result.Append (footer);
    6464
    65                         resp.ContentType = MimeType.GetMimeType (".html");
    66                         resp.ContentEncoding = Encoding.UTF8;
     65                        _resp.ContentType = MimeType.GetMimeType (".html");
     66                        _resp.ContentEncoding = Encoding.UTF8;
    6767                        byte[] buf = Encoding.UTF8.GetBytes (result.ToString ());
    68                         resp.ContentLength64 = buf.Length;
    69                         resp.OutputStream.Write (buf, 0, buf.Length);
     68                        _resp.ContentLength64 = buf.Length;
     69                        _resp.OutputStream.Write (buf, 0, buf.Length);
    7070                }
    7171        }

  • binary-improvements/MapRendering/Web/Handlers/SimpleRedirectHandler.cs

    r325 r351  
    55                private readonly string target;
    66
    7                 public SimpleRedirectHandler (string target, string moduleName = null) : base (moduleName) {
    8                         this.target = target;
     7                public SimpleRedirectHandler (string _target, string _moduleName = null) : base (_moduleName) {
     8                        target = _target;
    99                }
    1010
    11                 public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user,
    12                         int permissionLevel) {
    13                         resp.Redirect (target);
     11                public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
     12                        int _permissionLevel) {
     13                        _resp.Redirect (target);
    1414                }
    1515        }

  • binary-improvements/MapRendering/Web/Handlers/StaticHandler.cs

    r332 r351  
    1010                private readonly string staticPart;
    1111
    12                 public StaticHandler (string staticPart, string filePath, AbstractCache cache, bool logMissingFiles,
    13                         string moduleName = null) : base (moduleName) {
    14                         this.staticPart = staticPart;
    15                         datapath = filePath + (filePath [filePath.Length - 1] == '/' ? "" : "/");
    16                         this.cache = cache;
    17                         this.logMissingFiles = logMissingFiles;
     12                public StaticHandler (string _staticPart, string _filePath, AbstractCache _cache, bool _logMissingFiles,
     13                        string _moduleName = null) : base (_moduleName) {
     14                        staticPart = _staticPart;
     15                        datapath = _filePath + (_filePath [_filePath.Length - 1] == '/' ? "" : "/");
     16                        cache = _cache;
     17                        logMissingFiles = _logMissingFiles;
    1818                }
    1919
    20                 public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user,
    21                         int permissionLevel) {
    22                         string fn = req.Url.AbsolutePath.Remove (0, staticPart.Length);
     20                public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
     21                        int _permissionLevel) {
     22                        string fn = _req.Url.AbsolutePath.Remove (0, staticPart.Length);
    2323
    2424                        byte[] content = cache.GetFileContent (datapath + fn);
    2525
    2626                        if (content != null) {
    27                                 resp.ContentType = MimeType.GetMimeType (Path.GetExtension (fn));
    28                                 resp.ContentLength64 = content.Length;
    29                                 resp.OutputStream.Write (content, 0, content.Length);
     27                                _resp.ContentType = MimeType.GetMimeType (Path.GetExtension (fn));
     28                                _resp.ContentLength64 = content.Length;
     29                                _resp.OutputStream.Write (content, 0, content.Length);
    3030                        } else {
    31                                 resp.StatusCode = (int) HttpStatusCode.NotFound;
     31                                _resp.StatusCode = (int) HttpStatusCode.NotFound;
    3232                                if (logMissingFiles) {
    33                                         Log.Out ("Web:Static:FileNotFound: \"" + req.Url.AbsolutePath + "\" @ \"" + datapath + fn + "\"");
     33                                        Log.Out ("Web:Static:FileNotFound: \"" + _req.Url.AbsolutePath + "\" @ \"" + datapath + fn + "\"");
    3434                                }
    3535                        }

  • binary-improvements/MapRendering/Web/Handlers/UserStatusHandler.cs

    r332 r351  
    55namespace AllocsFixes.NetConnections.Servers.Web.Handlers {
    66        public class UserStatusHandler : PathHandler {
    7                 public UserStatusHandler (string moduleName = null) : base (moduleName) {
     7                public UserStatusHandler (string _moduleName = null) : base (_moduleName) {
    88                }
    99
    10                 public override void HandleRequest (HttpListenerRequest req, HttpListenerResponse resp, WebConnection user,
    11                         int permissionLevel) {
     10                public override void HandleRequest (HttpListenerRequest _req, HttpListenerResponse _resp, WebConnection _user,
     11                        int _permissionLevel) {
    1212                        JSONObject result = new JSONObject ();
    1313
    14                         result.Add ("loggedin", new JSONBoolean (user != null));
    15                         result.Add ("username", new JSONString (user != null ? user.SteamID.ToString () : string.Empty));
     14                        result.Add ("loggedin", new JSONBoolean (_user != null));
     15                        result.Add ("username", new JSONString (_user != null ? _user.SteamID.ToString () : string.Empty));
    1616
    1717                        JSONArray perms = new JSONArray ();
    … …  
    1919                                JSONObject permObj = new JSONObject ();
    2020                                permObj.Add ("module", new JSONString (perm.module));
    21                                 permObj.Add ("allowed", new JSONBoolean (perm.permissionLevel >= permissionLevel));
     21                                permObj.Add ("allowed", new JSONBoolean (perm.permissionLevel >= _permissionLevel));
    2222                                perms.Add (permObj);
    2323                        }
    … …  
    2525                        result.Add ("permissions", perms);
    2626
    27                         WebAPI.WriteJSON (resp, result);
     27                        WebAPI.WriteJSON (_resp, result);
    2828                }
    2929        }

  • binary-improvements/MapRendering/Web/MimeType.cs

    r332 r351  
    568568                        };
    569569
    570                 public static string GetMimeType (string extension) {
    571                         if (extension == null) {
    572                                 throw new ArgumentNullException ("extension");
     570                public static string GetMimeType (string _extension) {
     571                        if (_extension == null) {
     572                                throw new ArgumentNullException ("_extension");
    573573                        }
    574574
    575                         if (!extension.StartsWith (".")) {
    576                                 extension = "." + extension;
     575                        if (!_extension.StartsWith (".")) {
     576                                _extension = "." + _extension;
    577577                        }
    578578
    579579                        string mime;
    580580
    581                         return _mappings.TryGetValue (extension, out mime) ? mime : "application/octet-stream";
     581                        return _mappings.TryGetValue (_extension, out mime) ? mime : "application/octet-stream";
    582582                }
    583583        }

  • binary-improvements/MapRendering/Web/OpenID.cs

    r326 r351  
    2525                                              "/steam-intermediate.cer");
    2626
    27                 private static readonly bool verboseSsl = false;
     27                private const bool verboseSsl = false;
    2828                public static bool debugOpenId;
    2929
    … …  
    3535                        }
    3636
    37                         ServicePointManager.ServerCertificateValidationCallback = (srvPoint, certificate, chain, errors) => {
    38                                 if (errors == SslPolicyErrors.None) {
     37                        ServicePointManager.ServerCertificateValidationCallback = (_srvPoint, _certificate, _chain, _errors) => {
     38                                if (_errors == SslPolicyErrors.None) {
    3939                                        if (verboseSsl) {
    4040                                                Log.Out ("Steam certificate: No error (1)");
    … …  
    5050                                privateChain.ChainPolicy.ExtraStore.Add (caIntermediateCert);
    5151
    52                                 if (privateChain.Build (new X509Certificate2 (certificate))) {
     52                                if (privateChain.Build (new X509Certificate2 (_certificate))) {
    5353                                        // No errors, immediately return
    5454                                        privateChain.Reset ();

  • binary-improvements/MapRendering/Web/Web.cs

    r332 r351  
    2727                public Web () {
    2828                        try {
    29                                 int webPort = GamePrefs.GetInt (EnumGamePrefs.ControlPanelPort);
     29                                int webPort = GamePrefs.GetInt (EnumUtils.Parse<EnumGamePrefs> ("ControlPanelPort"));
    3030                                if (webPort < 1 || webPort > 65533) {
    3131                                        Log.Out ("Webserver not started (ControlPanelPort not within 1-65533)");
    … …  
    132132                }
    133133
    134                 public void SendLine (string line) {
    135                         connectionHandler.SendLine (line);
    136                 }
    137 
    138                 public void SendLog (string text, string trace, LogType type) {
     134                public void SendLine (string _line) {
     135                        connectionHandler.SendLine (_line);
     136                }
     137
     138                public void SendLog (string _text, string _trace, LogType _type) {
    139139                        // Do nothing, handled by LogBuffer internally
    140140                }
    141141
    142                 public static bool isSslRedirected (HttpListenerRequest req) {
    143                         string proto = req.Headers ["X-Forwarded-Proto"];
     142                public static bool isSslRedirected (HttpListenerRequest _req) {
     143                        string proto = _req.Headers ["X-Forwarded-Proto"];
    144144                        if (!string.IsNullOrEmpty (proto)) {
    145145                                return proto.Equals ("https", StringComparison.OrdinalIgnoreCase);
    … …  
    156156#endif
    157157
    158                 private void HandleRequest (IAsyncResult result) {
     158                private void HandleRequest (IAsyncResult _result) {
    159159                        if (!_listener.IsListening) {
    160160                                return;
    … …  
    167167#if ENABLE_PROFILER
    168168                        Profiler.BeginThreadProfiling ("AllocsMods", "WebRequest");
    169                         HttpListenerContext ctx = _listener.EndGetContext (result);
     169                        HttpListenerContext ctx = _listener.EndGetContext (_result);
    170170                        try {
    171171#else
    … …  
    314314                }
    315315
    316                 public static void SetResponseTextContent (HttpListenerResponse resp, string text) {
    317                         byte[] buf = Encoding.UTF8.GetBytes (text);
    318                         resp.ContentLength64 = buf.Length;
    319                         resp.ContentType = "text/html";
    320                         resp.ContentEncoding = Encoding.UTF8;
    321                         resp.OutputStream.Write (buf, 0, buf.Length);
     316                public static void SetResponseTextContent (HttpListenerResponse _resp, string _text) {
     317                        byte[] buf = Encoding.UTF8.GetBytes (_text);
     318                        _resp.ContentLength64 = buf.Length;
     319                        _resp.ContentType = "text/html";
     320                        _resp.ContentEncoding = Encoding.UTF8;
     321                        _resp.OutputStream.Write (buf, 0, buf.Length);
    322322                }
    323323        }

  • binary-improvements/MapRendering/Web/WebPermissions.cs

    r332 r351  
    33using System.IO;
    44using System.Xml;
    5 using UniLinq;
    65
    76namespace AllocsFixes.NetConnections.Servers.Web {
    … …  
    171170                }
    172171
    173                 private void OnFileChanged (object source, FileSystemEventArgs e) {
     172                private void OnFileChanged (object _source, FileSystemEventArgs _e) {
    174173                        Log.Out ("Reloading " + PERMISSIONS_FILE);
    175174                        Load ();
    … …  
    177176
    178177                private string GetFilePath () {
    179                         return GamePrefs.GetString (EnumGamePrefs.SaveGameFolder);
     178                        return GamePrefs.GetString (EnumUtils.Parse<EnumGamePrefs> ("SaveGameFolder"));
    180179                }
    181180
Note: See TracChangeset for help on using the changeset viewer.