Changeset 132 for binary-improvements


Ignore:
Timestamp:
Aug 26, 2014, 7:29:11 PM (5 years ago)
Author:
alloc
Message:

Fixes: Source cleanups

Location:
binary-improvements/7dtd-server-fixes/src
Files:
6 added
1 edited
3 moved

Legend:

Unmodified
Added
Removed
  • binary-improvements/7dtd-server-fixes/src/MapRendering/MapRendering.cs

    r130 r132  
    2424                private MapRenderBlockBuffer[] zoomLevelBuffers = new MapRenderBlockBuffer[Constants.ZOOMLEVELS];
    2525                private Color[] chunkColors = new Color[Constants.MAP_CHUNK_SIZE * Constants.MAP_CHUNK_SIZE];
    26                 private System.Timers.Timer chunkSaveTimer = new System.Timers.Timer (100);
     26                private System.Timers.Timer chunkSaveTimer = new System.Timers.Timer (500);
    2727                private bool renderingFullMap = false;
    2828
    2929                private MapRendering ()
    3030                {
    31                         string regionSaveDir = StaticDirectories.GetSaveGameRegionDir ();
    32                         rfm = new RegionFileManager (regionSaveDir, regionSaveDir, 1, false);
    3331                        Constants.MAP_DIRECTORY = StaticDirectories.GetSaveGameDir () + "/map";
    3432
     
    6462                        MicroStopwatch microStopwatch = new MicroStopwatch ();
    6563
     64                        string regionSaveDir = StaticDirectories.GetSaveGameRegionDir ();
     65                        rfm = new RegionFileManager (regionSaveDir, regionSaveDir, 1, false);
     66
    6667                        if (Directory.Exists (Constants.MAP_DIRECTORY))
    6768                                Directory.Delete (Constants.MAP_DIRECTORY, true);
     
    8889                        }
    8990                        SaveAllBlockMaps (null, null);
     91
     92                        rfm = null;
    9093
    9194                        byte[] array = fullMapTexture.EncodeToPNG ();
  • binary-improvements/7dtd-server-fixes/src/NetConnections/ConsoleOutputSeparator.cs

    r130 r132  
    44using UnityEngine;
    55
    6 namespace AllocsFixes
     6namespace AllocsFixes.NetConnections
    77{
    88        public class ConsoleOutputSeparator
    99        {
    10                 public struct AllocsTelnetCommand
     10                public struct NetCommand
    1111                {
    1212                        public string command;
    13                         public AllocsTelnetConnection client;
     13                        public IConnection client;
    1414
    15                         public AllocsTelnetCommand (string _cmd, AllocsTelnetConnection _client)
     15                        public NetCommand (string _cmd, IConnection _client)
    1616                        {
    1717                                command = _cmd;
     
    2020                }
    2121
    22                 private static List<AllocsTelnetCommand> telnetCommandQueue = new List<AllocsTelnetCommand> ();
     22                private static List<NetCommand> netCommandQueue = new List<NetCommand> ();
    2323                private static bool isCurrentCommandFromClient = false;
    24                 private static AllocsTelnetConnection issuerOfCurrentTelnetCommand;
     24                private static IConnection issuerOfCurrentCommand;
    2525
    2626                public static void C_ExecuteCmdFromClient (ConsoleSdtd console, NetworkPlayer _networkPlayer, string _playerID, string _command)
     
    2828                        Log.Out ("Executed command \"" + _command + "\" from player \"" + _playerID + "\"");
    2929
    30                         object obj = telnetCommandQueue;
     30                        object obj = netCommandQueue;
    3131                        Monitor.Enter (obj);
    3232                        try {
     
    5151                                );
    5252                        } else {
    53                                 if (console.telnetServer != null && issuerOfCurrentTelnetCommand != null)
    54                                         AllocsNetTelnetServer.WriteToClient_Single (_line, issuerOfCurrentTelnetCommand);
     53                                if (console.telnetServer != null && issuerOfCurrentCommand != null)
     54                                        NetTelnetServer.WriteToClient_Single (_line, issuerOfCurrentCommand);
    5555                                else if (ControlPanel.IsStarted ())
    5656                                        ControlPanel.AddTextToOutputBuffer (_line);
     
    6060                public static void C_Run (ConsoleSdtd console)
    6161                {
    62                         if (telnetCommandQueue.Count > 0) {
    63                                 object obj = telnetCommandQueue;
     62                        if (netCommandQueue.Count > 0) {
     63                                object obj = netCommandQueue;
    6464                                Monitor.Enter (obj);
    6565                                try {
    66                                         issuerOfCurrentTelnetCommand = telnetCommandQueue [0].client;
    67                                         console.ExecuteRemoteCmdInternal (telnetCommandQueue [0].command, false);
    68                                         telnetCommandQueue.RemoveAt (0);
    69                                         issuerOfCurrentTelnetCommand = null;
     66                                        issuerOfCurrentCommand = netCommandQueue [0].client;
     67                                        console.ExecuteRemoteCmdInternal (netCommandQueue [0].command, false);
     68                                        netCommandQueue.RemoveAt (0);
     69                                        issuerOfCurrentCommand = null;
    7070                                } finally {
    7171                                        Monitor.Exit (obj);
     
    7474                }
    7575
    76                 public static void QueueTelnetCommand (string _line, AllocsTelnetConnection _con)
     76                public static void QueueNetCommand (string _line, IConnection _con)
    7777                {
    78                         object obj = telnetCommandQueue;
     78                        object obj = netCommandQueue;
    7979                        Monitor.Enter (obj);
    8080                        try {
    81                                 telnetCommandQueue.Add (new AllocsTelnetCommand (_line, _con));
     81                                netCommandQueue.Add (new NetCommand (_line, _con));
    8282                        } finally {
    8383                                Monitor.Exit (obj);
  • binary-improvements/7dtd-server-fixes/src/NetConnections/Servers/Telnet/Telnet.cs

    r130 r132  
    11using System;
    22using System.Collections.Generic;
    3 using System.IO;
    43using System.Net;
    54using System.Net.Sockets;
    6 using System.Reflection;
    75using System.Threading;
    86
    9 namespace AllocsFixes
     7namespace AllocsFixes.NetConnections.Servers.Telnet
    108{
    11         public class AllocsNetTelnetServer
     9        public class Telnet : IServer
    1210        {
    1311                private static Thread telnetThread = null;
     
    1513                private static bool closed = false;
    1614                private static bool authEnabled = false;
    17                 private static List<AllocsTelnetConnection> connections = new List<AllocsTelnetConnection> ();
     15                private static List<TelnetConnection> connections = new List<TelnetConnection> ();
    1816
    19                 public static void init (int port)
     17                public Telnet (int port)
    2018                {
    2119                        try {
    22                                 Log.Out ("[7dtd-server-fixes by Alloc] Version: " + Assembly.GetExecutingAssembly ().GetName ().Version);
    2320                                authEnabled = GamePrefs.GetString (EnumGamePrefs.TelnetPassword).Length != 0;
    2421                                if (authEnabled)
     
    2623                                else
    2724                                        listener = new TcpListener (IPAddress.Loopback, port);
    28                                 telnetThread = ThreadMaster.Create ("thread Allocs TelnetListenThread", new ThreadStart (telnetListenThread));
     25                                telnetThread = ThreadMaster.Create ("thread TelnetListenThread", new ThreadStart (telnetListenThread));
    2926                                telnetThread.Start ();
    30                                 Log.Out ("Started Allocs NetTelnetServer thread on " + port);
     27                                Log.Out ("Started Telnet thread on " + port);
    3128                        } catch (Exception e) {
    32                                 Log.Out ("Error in AllocsTelnetServer.init: " + e);
     29                                Log.Out ("Error in Telnet.ctor: " + e);
    3330                        }
    3431                }
    3532
    36                 private static void telnetListenThread ()
     33                private void telnetListenThread ()
    3734                {
    3835                        try {
    39                                 Log.Out ("Started thread_Allocs_TelnetListenThread()");
     36                                Log.Out ("Started thread_TelnetListenThread()");
    4037                                listener.Start ();
    4138                                while (!closed) {
    4239                                        Thread.Sleep (10);
    4340                                        if (listener.Pending ()) {
    44                                                 AllocsTelnetConnection c = new AllocsTelnetConnection (listener.AcceptTcpClient (), authEnabled);
     41                                                TelnetConnection c = new TelnetConnection (listener.AcceptTcpClient (), authEnabled);
    4542                                                connections.Add (c);
    4643                                                Log.Out ("Telnet connection from: " + c.GetEndPoint ());
     
    5249                                        }
    5350
    54                                         foreach (AllocsTelnetConnection c in connections) {
     51                                        foreach (TelnetConnection c in connections) {
    5552                                                if (c.IsClosed ()) {
    5653                                                        c.Close ();
     
    7976                                                                }
    8077                                                                Log.Out ("Telnet executed \"" + line + "\" from: " + c.GetEndPoint ());
    81                                                                 ConsoleOutputSeparator.QueueTelnetCommand (line, c);
     78                                                                ConsoleOutputSeparator.QueueNetCommand (line, c);
    8279                                                        }
    8380                                                }
    8481                                        }
    8582                                }
    86                                 Log.Out ("Exited thread_Allocs_TelnetListenThread()");
     83                                Log.Out ("Exited thread_TelnetListenThread()");
    8784                                ThreadMaster.Remove (Thread.CurrentThread.Name);
    8885                        } catch (Exception ex) {
    89                                 Log.Out ("Error in Allocs telnetListenThread: " + ex.Message);
     86                                Log.Out ("Error in TelnetListenThread: " + ex.Message);
    9087                                Log.Out ("Stack Trace: " + ex.StackTrace);
    9188                        }
    9289                }
    9390
    94                 private static void LoginMessage (AllocsTelnetConnection c)
     91                private void LoginMessage (TelnetConnection c)
    9592                {
    9693                        c.WriteLine ("*** Connected with 7DTD server.");
     
    112109                }
    113110
    114                 private static string lineCorrecter (string line)
     111                private string lineCorrecter (string line)
    115112                {
    116113                        string res = "";
     
    123120                }
    124121
    125                 public static void Disconnect ()
     122                public void Disconnect ()
    126123                {
    127124                        try {
     
    130127                                        listener.Stop ();
    131128                                }
    132                                 foreach (AllocsTelnetConnection c in connections) {
     129                                foreach (TelnetConnection c in connections) {
    133130                                        c.Close ();
    134131                                }
    135132                                Thread.Sleep (100);
    136133                        } catch (Exception e) {
    137                                 Log.Out ("Error in AllocsTelnetServer.Disconnect: " + e);
     134                                Log.Out ("Error in Telnet.Disconnect: " + e);
    138135                        }
    139136                }
    140137
    141                 public static void SetConsole (ConsoleSdtd console)
    142                 {
    143                 }
    144 
    145                 private static void RemoveClosedConnections ()
     138                private void RemoveClosedConnections ()
    146139                {
    147140                        try {
    148                                 foreach (AllocsTelnetConnection c in connections) {
     141                                foreach (TelnetConnection c in connections) {
    149142                                        if (c.IsClosed ()) {
    150143                                                c.Close ();
     
    152145                                }
    153146                        } catch (Exception e) {
    154                                 Log.Out ("Error in AllocsTelnetServer.RemoveClosedConnections: " + e);
     147                                Log.Out ("Error in Telnet.RemoveClosedConnections: " + e);
    155148                        }
    156149                }
    157150
    158                 public static void WriteToClient (string line)
     151                public void WriteToClient (string line)
    159152                {
    160153                        if (line == null) {
     
    162155                        }
    163156                        RemoveClosedConnections ();
    164                         foreach (AllocsTelnetConnection c in connections) {
     157                        foreach (TelnetConnection c in connections) {
    165158                                if (c.IsAuthenticated ())
    166159                                        c.WriteLine (line);
     
    168161                }
    169162
    170                 public static void WriteToClient_Single (string line, AllocsTelnetConnection client)
     163                public void WriteToClient_Single (string line, IConnection client)
    171164                {
    172165                        if (line == null) {
     
    174167                        }
    175168                        RemoveClosedConnections ();
    176                         foreach (AllocsTelnetConnection c in connections) {
    177                                 if (c.IsAuthenticated () && (c == client))
    178                                         c.WriteLine (line);
     169                        foreach (TelnetConnection con in connections) {
     170                                if (con == client) {
     171                                        if (con.IsAuthenticated ())
     172                                                con.WriteLine (line);
     173                                }
    179174                        }
    180175                }
     176
    181177        }
    182178}
     179
  • binary-improvements/7dtd-server-fixes/src/NetConnections/Servers/Telnet/TelnetConnection.cs

    r130 r132  
    33using System.Net.Sockets;
    44
    5 namespace AllocsFixes
     5namespace AllocsFixes.NetConnections.Servers.Telnet
    66{
    7 public class AllocsTelnetConnection
    8 {
    9         private bool authenticated = false;
    10         private bool authEnabled;
    11         private TcpClient client;
    12         private NetworkStream stream;
    13         private string lineBuffer = string.Empty;
    14         private EndPoint endpoint;
     7        public class TelnetConnection : IConnection
     8        {
     9                private bool authenticated = false;
     10                private bool authEnabled;
     11                private TcpClient client;
     12                private NetworkStream stream;
     13                private string lineBuffer = string.Empty;
     14                private EndPoint endpoint;
    1515
    16         public AllocsTelnetConnection (TcpClient client, bool authEnabled)
    17         {
    18                 this.authEnabled = authEnabled;
    19                 this.client = client;
    20                 this.stream = client.GetStream ();
    21                 this.endpoint = client.Client.RemoteEndPoint;
    22         }
     16                public TelnetConnection (TcpClient client, bool authEnabled)
     17                {
     18                        this.authEnabled = authEnabled;
     19                        this.client = client;
     20                        this.stream = client.GetStream ();
     21                        this.endpoint = client.Client.RemoteEndPoint;
     22                }
    2323
    24         public EndPoint GetEndPoint ()
    25         {
    26                 return endpoint;
    27         }
     24                public EndPoint GetEndPoint ()
     25                {
     26                        return endpoint;
     27                }
    2828
    29         private void WriteByte (byte v)
    30         {
    31                 if (!IsClosed () && stream.CanWrite) {
    32                         stream.WriteByte (v);
    33                 }
    34         }
    35 
    36         public void WriteLine (string s)
    37         {
    38                 try {
     29                private void WriteByte (byte v)
     30                {
    3931                        if (!IsClosed () && stream.CanWrite) {
    40                                 for (int i = 0; i < s.Length; i++) {
    41                                         WriteByte ((byte)s [i]);
    42                                 }
    43                                 WriteByte(13);
    44                                 WriteByte (10);
    45                         }
    46                 } catch (Exception e) {
    47                         Log.Out("Error writing to client: " + e);
    48                 }
    49         }
    50 
    51         public void Close ()
    52         {
    53                 if (client != null)
    54                         client.Close ();
    55                 client = null;
    56         }
    57 
    58         public bool IsClosed ()
    59         {
    60                 if (client != null && !client.Connected) {
    61                         Log.Out ("Telnet connection interrupted: " + endpoint);
    62                 }
    63                 return (client == null) || (!client.Connected);
    64         }
    65 
    66         public bool IsAuthenticated ()
    67         {
    68                 return !authEnabled || authenticated;
    69         }
    70 
    71         public void SetAuthenticated ()
    72         {
    73                 authenticated = true;
    74         }
    75 
    76         public bool Read ()
    77         {
    78                 while (!IsClosed() && stream.CanRead && stream.DataAvailable) {
    79                         int b = stream.ReadByte ();
    80                         if (b == '\r' || b == '\n') {
    81                                 if (lineBuffer.Length > 0)
    82                                         return true;
    83                         } else {
    84                                 lineBuffer += (char)b;
     32                                stream.WriteByte (v);
    8533                        }
    8634                }
    87                 return false;
    88         }
    8935
    90         public string GetLine ()
    91         {
    92                 string res = lineBuffer;
    93                 lineBuffer = string.Empty;
    94                 return res;
     36                public void WriteLine (string s)
     37                {
     38                        try {
     39                                if (!IsClosed () && stream.CanWrite) {
     40                                        for (int i = 0; i < s.Length; i++) {
     41                                                WriteByte ((byte)s [i]);
     42                                        }
     43                                        WriteByte (13);
     44                                        WriteByte (10);
     45                                }
     46                        } catch (Exception e) {
     47                                Log.Out ("Error writing to client: " + e);
     48                        }
     49                }
     50
     51                public void Close ()
     52                {
     53                        if (client != null)
     54                                client.Close ();
     55                        client = null;
     56                }
     57
     58                public bool IsClosed ()
     59                {
     60                        if (client != null && !client.Connected) {
     61                                Log.Out ("Telnet connection interrupted: " + endpoint);
     62                        }
     63                        return (client == null) || (!client.Connected);
     64                }
     65
     66                public bool IsAuthenticated ()
     67                {
     68                        return !authEnabled || authenticated;
     69                }
     70
     71                public void SetAuthenticated ()
     72                {
     73                        authenticated = true;
     74                }
     75
     76                public bool Read ()
     77                {
     78                        while (!IsClosed() && stream.CanRead && stream.DataAvailable) {
     79                                int b = stream.ReadByte ();
     80                                if (b == '\r' || b == '\n') {
     81                                        if (lineBuffer.Length > 0)
     82                                                return true;
     83                                } else {
     84                                        lineBuffer += (char)b;
     85                                }
     86                        }
     87                        return false;
     88                }
     89
     90                public string GetLine ()
     91                {
     92                        string res = lineBuffer;
     93                        lineBuffer = string.Empty;
     94                        return res;
     95                }
     96
    9597        }
    9698}
    97 }
Note: See TracChangeset for help on using the changeset viewer.