corrade-vassal – Diff between revs 13 and 16

Subversion Repositories:

?pathlinks?

Rev 13 – Go to most recent revision – Details – Blame – Last modification – View Log

 using System.Text;
 using System.Threading.Tasks;
 namespace wasSharp
 {
-    public class Cryptography
+    public static class Cryptography
+    {
         ///////////////////////////////////////////////////////////////////////////
         //  Copyright (C) Wizardry and Steamworks 2014 - License: GNU GPLv3      //
         ///////////////////////////////////////////////////////////////////////////
         /// <param name="plugs">the letter representing the start character for the rotor</param>
         /// <param name="reflector">any one of: B, b, C, c</param>
         /// <returns>either a decrypted or encrypted string</returns>
         public static string ENIGMA(string message, char[] rotors, char[] plugs, char reflector)
+        {
-            Dictionary<char, char[]> def_rotors = new Dictionary<char, char[]>
+            var def_rotors = new Dictionary<char, char[]>
+            {
+                {
                     '1', new[]
+                    {
                         'e', 'k', 'm', 'f', 'l',
                         'd'
+                    }
+                }
             };
-            Dictionary<char, char[]> def_reflectors = new Dictionary<char, char[]>
+            var def_reflectors = new Dictionary<char, char[]>
+            {
+                {
                     'B', new[]
+                    {
+                    }
+                }
             };
             // Setup rotors from plugs.
-            foreach (char rotor in rotors)
+            foreach (var rotor in rotors)
             {
-                char plug = plugs[Array.IndexOf(rotors, rotor)];
+                var plug = plugs[Array.IndexOf(rotors, rotor)];
-                int i = Array.IndexOf(def_rotors[rotor], plug);
+                var i = Array.IndexOf(def_rotors[rotor], plug);
                 if (i.Equals(0)) continue;
                 def_rotors[rotor] = Arrays.ConcatenateArrays(new[] {plug},
                     Arrays.GetSubArray(Arrays.DeleteSubArray(def_rotors[rotor], i, i), i, -1),
                     Arrays.GetSubArray(Arrays.DeleteSubArray(def_rotors[rotor], i + 1, -1), 0, i - 1));
             }
-            StringBuilder result = new StringBuilder();
+            var result = new StringBuilder();
-            foreach (char c in message)
+            foreach (var c in message)
+            {
                 if (!char.IsLetter(c))
+                {
                     result.Append(c);
                     continue;
                 }
                 // Normalize to lower.
-                char l = char.ToLower(c);
+                var l = char.ToLower(c);
                 Action<char[]> rotate = o =>
+                {
-                    int i = o.Length - 1;
+                    var i = o.Length - 1;
                     do
                 // Forward pass through the Enigma's rotors.
                 rotate.Invoke(rotors);
                 // Reflect
-                int x = Array.IndexOf(def_reflectors[reflector], l);
+                var x = Array.IndexOf(def_reflectors[reflector], l);
                 l = (x + 1)%2 == 0 ? def_reflectors[reflector][x - 1] : def_reflectors[reflector][x + 1];
         /// <param name="input">the input to expand to</param>
         /// <param name="enc_key">the key to expand</param>
         /// <returns>the expanded key</returns>
         public static string VIGENEREExpandKey(string input, string enc_key)
+        {
-            string exp_key = string.Empty;
+            var exp_key = string.Empty;
             int i = 0, j = 0;
             do
+            {
-                char p = input[i];
+                var p = input[i];
                 if (!char.IsLetter(p))
+                {
                     exp_key += p;
                     ++i;
                     continue;
+                }
-                int m = j%enc_key.Length;
+                var m = j%enc_key.Length;
                 exp_key += enc_key[m];
                 ++j;
                 ++i;
             } while (i < input.Length);
             return exp_key;
                 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
                 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'
             };
             enc_key = VIGENEREExpandKey(input, enc_key);
-            string result = string.Empty;
+            var result = string.Empty;
-            int i = 0;
+            var i = 0;
             do
             {
-                char p = input[i];
+                var p = input[i];
                 if (!char.IsLetter(p))
+                {
                     result += p;
                     ++i;
                     continue;
                 }
-                char q =
+                var q =
                     Arrays.ReversePermuteArrayElements(a, Array.IndexOf(a, enc_key[i]))[
                         Array.IndexOf(a, char.ToLowerInvariant(p))];
                 if (char.IsUpper(p))
+                {
                 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
                 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'
             };
             enc_key = VIGENEREExpandKey(input, enc_key);
-            string result = string.Empty;
+            var result = string.Empty;
-            int i = 0;
+            var i = 0;
             do
             {
-                char p = input[i];
+                var p = input[i];
                 if (!char.IsLetter(p))
+                {
                     result += p;
                     ++i;
                     continue;
                 }
-                char q =
+                var q =
                     a[
                         Array.IndexOf(Arrays.ReversePermuteArrayElements(a, Array.IndexOf(a, enc_key[i])),
                             char.ToLowerInvariant(p))];
                 if (char.IsUpper(p))
+            {
                 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
                 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'
             };
-            char[] input = data.ToCharArray();
+            var input = data.ToCharArray();
             Parallel.ForEach(Enumerable.Range(0, data.Length), i =>
+            {
-                char e = input[i];
+                var e = input[i];
                 if (!char.IsLetter(e)) return;
-                int x = 25 - Array.BinarySearch(a, char.ToLowerInvariant(e));
+                var x = 25 - Array.BinarySearch(a, char.ToLowerInvariant(e));
                 if (!char.IsUpper(e))
+                {
                     input[i] = a[x];