v1.2.0

• Improved performance:

  • 129.7% EncLong performance increase
  • 578.1% EncInt performance increase
  • 154.1% EncString performance increase

• Improved the encryption algorithm of the EncDouble & EncFloat, this is the
  reason they are a bit slower now, but the encryption is miles better

• Changed the license to MIT from GNU GPL 3.0

• Added an official Unity Package

• Reorganized the repository, now there are:

  • src folder containing the solution and projects
  • build folder containing the build and executables
  • packages folder containing the NuGet and Unity package

• Updated the links in the README and the scripts

v1.1.0

• A package of the project has been published to the NuGet package manager.
• Fixed a bug that caused an error with EncTypes inside a Unity project solution.
• Every encrypted variable type (EncType) is now inside the namespace "EncTypes".
• Separated the "Benchmark" application project and the "EncTypes" class library.
• Renamed the Benchmark application project from Variable-Encryption to Benchmark.
• Renamed the Solution from VariableEncryption to VarEnc.
• Now the benchmark application executable file has a custom icon.
• Moved the solution to the root folder.
• Added a category to the README about cloning, importing and packages.
• Combined the "Documentations" category in the README with the "EncTypes" category.

v1.0

EncTypes updates

• Changed the encryption algorithm.
  Every EncType is now 10 times more encrypted than before.

• The new encryption method made the EncInt, EncDouble, EncFloat only 2 times slower than before.

• Fixed a severe bug in the EncTypes, that resulted in data loss. It has been fixed by changing the encryption algorithm to the one used by the EncString class.

• Added 10 more operator overloads to every EncType

• Now the size in bytes of every EncType is smaller.

  • EncInt size from 24 bytes to 8
  • EncLong size from 48 bytes to 16
  • EncFloat size from 24 bytes to 8
  • EncDouble size from 24 bytes to 16
  • EncDecimal size from 48 bytes to 32

• EncString - Improved performance by 50% to 70%

• EncDecimal - Improved performance by 100% to 120%

• EncLong - Improved performance by 110% to 130%

• EncInt & EncLong

  • Added support for bitwise operators
  • Fixed some operators overloads

Benchmarking Application

• Now when you compare string types, the benchmark will be 50 times faster

• Removed the older versions of EncInt, EncFloat, and EncDouble.
  Comparing them now is useless because they use a different encryption algorithm.
  They are 2 times slower but 10 times more encrypted.

• Changed the way the application used to test a floating-point type variable

• Organized the Benchmark Application's solution

  • Added descriptions to classes
  • Separated methods and class members to regions
  • Deleted classes and methods with no use

General Updates

• Now the comparisons are separated into chunks in the menu by their category

• Added badges to the README

v0.9.0

• Improved performance and efficiency

  • EncInt & EncLong
    Improved efficiency and performance by 32% to 41%
  • EncDouble & EncFloat & EncLong
    Improved efficiency and performance by 24% to 35%
  • EncString
    Minor performance improvement 1% to 4%

• Improved encryption level in all EncTypes, now the encrypted value and both encryption keys are read-only variables

• Updated performance information in the main README

• Added the current version of the EncTypes to the benchmark, you can compare them yourself

• Added the option to run the recent benchmark again by pressing Space when the results are shown, and by typing "p" or "prev" in the menu.

• Fixed many bugs in the benchmark executable related to input

0.8.0

• Improved the EncString performance by 28%
• Improved the EncInt & EncLong performance by 9%
• Improved the EncFloat & EncDouble & EncDecimal performance by 13%
• Benchmarking application
  • Added the option to enter multiple choices at once. For example, if you know you'll choose 3 in the first section, and then 4, instead of inputting them separately, you can type them all together. (just separate them with spaces)
  • Now the current version of the EncTypes is displayed.
  • Fixed some visual problems.
  • I've added comparisons between EncType and their older versions. (EncInt vs EncInt (0.3.0) etc...)
  • I've added to the final results of the benchmark how many changes can be performed per second on each variable.
  • Until now the benchmark results were 100% inaccurate. I fixed it, so now it shows accurate results. (It seems strange to me that the EncInt is just 1% less effective than a normal int. Because it's stupid and doesn't make sense. Actually, the int is 60 times better than the EncInt)
  • If you don't know, the benchmark performs changes to a variable and checks how many times it can be changed. Because I've added to the benchmarking loops a method that prints the value of the changed variable, the results were slower or faster mostly because of the printing time. So I removed the printing of the variable while it's benchmarking. Now it'll just print the result after each test.
  • I brought back the Benchmark Application's Solution folder.
  • Now the console window will have the name of the application on it.
• Added new info to the main README.
• Removed the .gitignore file (was useless)
• Removed useless debug files from the Benchmark folder.
  Only important files for the executable remained.

0.7.0

• Added method, fields, and constructors to all EncTypes.
  Now they have all the functionality of their normal version.
  • EncString class changes
    • Added 4 fields
    • Added ≈70 methods
    • Added constructors (4)
    • Added 2 operator overloads for combining strings
  • EncInt & EncLong structs changes
    • Added 2 fields
    • Added 10 methods
    • Added ≈65 operator overloads
  • EncFloat & EncDouble structs changes
    • Added 6 fields
    • Added 10 methods
    • Added ≈75 operator overloads
  • EncDecimal struct changes
    • Added 5 fields
    • Added 10 methods
    • Added ≈90 operator overloads
• Added the updated types to the benchmark and rebuilt the executable.
• Added detailed example of using the Benchmark console application.
• Deleted the WIKI
• Added a long README that contains all the WIKI content and more.

0.6.0

• Changed the repository's name to VarEnc from Variable-Encryption
• Recreated the benchmarking console application.
  • The results of the benchmark are more detailed now (it writes in percentage how well the better type performed)
  • Instead of picking two variable types to compare, you just need to choose the EncType against its normal version from a list of all the comparisons you can make (EncInt vs int, EncDouble vs double, etc).
  • Now you won't choose the number of tests and changes in a benchmark. You just need to pick how long you want the benchmark to be (Fastest, Very Fast, Fast, Normal, Medium, Long, Very Long). After that, just pick a benchmark preset from the list and wait for it to finish.
• Added some images for every page in the WIKI
• Removed the benchmark's solution (Will come back when it's finished)
• The main README has been rewritten.
• Deleted the "Notes" folder (just contained the content of these patch notes)

0.5.0

New Encrypted Types

• EncFloat - A type for containing a "Single" type (a float).
  The same concept as the EncInt struct.

• EncDouble - A type for containing a "Double" type.
  The same concept as the struct above.

• EncDecimal - A type for containing a "Decimal" type.
  The same concept as the struct above.

• EncString - An EncType class for a string type,
  that uses an XOR bitwise encryption.

Classes and Structs INDEPENDENCE

I all the previous versions, all the classes, the structs, and the EncTypes were dependent on the EncryptionTools.
A class that had methods for getting random numbers. Now there's no need for that.
Every single EncType now is independent and can work alone.

Benchmark Application

The VarEnc repo now contains a benchmark (exe)cutable to test the efficiency of its types.
When running, a benchmark will perform a certain amount tests for each variable type you choose and in each test,
the application will perform changes to these variables a certain amount of time.

If it sounds complicated, don't worry. It is very simple and it has a full page in the WIKI (:

You can lunch the Benchmark executable from the "Benchmark" library.
You can also build the benchmark executable yourself with the Solution contained in the repo.

Removed classes

• EncryptionTools, this class contained methods for getting a random variable.
  This was completely redundant and made unnecessary dependencies.
• EncryptedInt, this class was the first in this project.
  Now it's useless with the new Enc structs.

0.3.2

• Changed the names of the structs "eint" and "elong" to "EncInt" and "EncLong"
• Deleted all generic classes (EncryptedInteger, EncryptedInt08, etc...)

0.3.1

• Changed the name of the repository from "SimpleEncryptionTools" to "Variable-Encryption"
• Added a Code of Conduct file
• Added a Contributing file
• Added Issue templates
• Added a social preview image