Tons of changes, they can be viewed here:
github.com
github.com
github.com
github.com
Appreciate
@MrDan4es's testing during this release, and reports.
A Fougerite update after more than a year? Wasn't 1.7.9E supposed to be the "last" update of Fougerite?
Yeah, you might be saying that... and you would be right. Last year I have graduated as a Computer Science Engineer. During the years after my Java carrier in Minecraft, Rust Legacy was truly an astonishing journey. I was a noob, and totally new to the coding in terms of C# back in 2015. This project is the reason why I have gained so much experience, and started my path alongside the current jobs I have, and my reverse engineering career. From 2020, and during these absent months I never even bared to look at Fougerite's discord. I knew that so many things could be improved with my knowledge yet I wanted to let this project go. There are always fresh people, maybe not a lot, but there still are who join into the world of rust legacy, to start and gain experiences on how things were working during the Fougerite life cycle. Researching, facing problems, and what not.
So I couldn't just let this project go, and I still promised I'd push out a big release with all the fixes I had in my mind. All the problems that I didn't understand in 2015-2018. Obviously there are still things to work on, but most of the things cannot be caved out due to many plugins relying on the current API's build up. Even though there are parts that are clean, there are parts that should be cleaned up, or solved.
To be honest, I currently have 3 projects I work on, and there is absolutely no chance I'd take on updating Fougerite regularly. However I do wish to sometimes make hotfixes, and propose new opportunities that can be still caved out from legacy. What you can put into or make out of this depends on you honestly.
Since 1.8.0 is done, my next aim will be to do a similar big stabilization update for RustBuster. There is going to be plenty of work needed right there. Anyway, enough with the words, here are the changes briefly.
* A new event:
On_ConsoleWithCancel. This event allows you to cancel console commands easily. This was not possible before, but now It pretty much is.
More on this on the wiki later.
* Fougerite has been upgraded to the latest C# version. (The language, API set is still Mono, .NET 3.5)
* Tons of refactoring, and clean up in the project. And this was really a big work.
* Fougerite is now built via SERVER preprocessor. Some API sets in Rust Legacy Server checks for the SERVER constant, and since I just patched one function using It, It was necessary to declare.
* Lots of Code quality improvements
* Fixed an issue at HurtEvent, where in some cases It would assign the "Attacker" property to the "Victim" property as well, causing a mismatch between the two players. (I only noticed this by code, surprised that nobody noticed this through the years lol
https://github.com/Notulp/Fougerite/pull/152/files#diff-f051a1552b30c8caec3394e122aa6ea5a6e70d0d1b886bf4dc577fe32df00286L73)
* Removed useless, or unused patching functions.
* A new event:
On_GrenadeThrow. This event can be used in any scripting language unlike the shooting events which are only available for C#. More on this on the wiki later.
* Added
SuperFastHash algorithm to the API.
* You can now use Util.GetUtil().SuperFastHash(string), Util.GetUtil().SHA1Hash(string), Util.GetUtil().MD5Hash(string) to generate hashes for specific inputs.
* The Web class has been completely reworked. Web.GET, Web.POST, Web.GETWithSSL, Web.POSTWithSSL have been marked as obsolete. These are blocking functions, and they shouldn't be used on the main thread unless you intentionally tend to cause laggs on the server. I have added tons of new references (dlls), which gives the opportunity for the inner .NET API to access new functions, and with this you also have deeper .NET API available. One of this is that we are now able to process new modern TLS protocols / SSL certificates on websites. Web class defines a default connection limit count of 200 now.
* Web.CreateAsyncHTTPRequest(url, callback, method, headers, timeout, compression) has been added. More on this on the wiki later.
* NewtonSoft has been updated to the latest version.
* Oracle Mysql has been updated to 6.9.8, the latest possible version we can update to.
* Following DLLs were added or updated: Mono.Data.Tds.dll, Mono.Security.dll, Mysql.Data.dll, Mysql.Data.CF.dll, Mysql.Data.Entity.dll, Mysql.Fabric.Plugin.dll, Mysql.Web.dll, System.Data.dll, System.Drawing.dll, System.Runtime.Serialization.dll, System.Xml.dll, System.Xml.Linq.dll (These contain new APIs, bugfixes, and what not)
* Facepunch.MeshBatch dll's issue has been re-patched. Instead of a crappy try catch, we actually check for the gameobject being null, thus avoiding the exception. (
https://fougerite.com/threads/nullreferenceexception-on-entity-destroy.435/#post-4644 )
*
A new set of .NET 4.0 standardized classes implemented. ConcurrentDictionary, ConcurrentEnumerator, ConcurrentList, LockCookie, LockQueue, ReadWriterLock. You can use these in your plugins! Go look these up on google, and read the microsoft documentation page what they are for. Basically these are classes that we should have implemented years ago. Some things in legacy must be done on a new thread if we want to avoid causing laggs to the server. However, there are functionalities after that must be ran on the main thread to avoid crashes from UnityEngine. For that purpose we introduced the class Loom which old developers already know about. It's on the wiki.
For example, ConcurrentDictionary, and ConcurrentList is a Dictionary, and List in C#, but they are thread safe, meaning that multiple threads can access these collections, and safely modifying them, instead of causing errors while they update the same entires.
* Fougerite's main config reading now handles errors, and logs them if they were to happen
*
I shall introduce the new Cache system, the PlayerCache. This cache stores the connected player's history, meaning that the steamid stores the player's current name, used names in the past, and all the used IP addresses. It can be used via the PlayerCache class from script plugins, more on this later. This cache is thread safe, and Fougerite uses It to find the name of entities owners, when they didn't connect since last start (As rust doesn't store this info), and can be used for many other things as well.
*
Server.Players is now completely thread safe, and the same goes for the Server.Cache (Well almost..). Server.Cache can be directly accessed to retain API functionality, but this shouldn't be used in this way, It should be Server.GetCachePlayer(steamid) that should be used instead. This cache by default from server runtime stores all the connected player's Player class, and we use this in the API to quickly find the players that we are looking for by ID.
* I shall introduce the new
PermissionSystem! This has actually been slipped into 1.7.9E, but not in a perfect condition, and not finished either. Now all the API is finished, some bugs were fixed, and the good news is that PermissionSystem is also thread safe! This was actually a very necessary standardization needed for the plugins, and If I remember well, I updated almost all of my plugins for this. There are some I need to finish as well.
Before you upgrade, please open up Save/GroupPermissions.json via Notepad++ program, and check all entries. Look for the "UniqueID" properties, and ensure that every number is not a negative one. Where you spot a '-' sign just delete those and save the file. Or you can just delete GroupPermissions if you haven't been using It at all.
* For this new PermissionSystem I wrote a
new plugin as well to complement It. You can find It in the Modules folder under "
PermissionManager". This plugin contains several new commands, that you can use to manage users and groups, and their permissions. More on this later on the wiki.
* Rust++ now completely supports PermissionSystem. It uses the same permission names as It used already.
* Patching is required. Use the Patcher on cleaned dlls, or use the prepatched dlls from the prepatch folder!
Gathering all these new dlls were taking efforts, mostly due to the fact that we are limited in a specific mono API.
I guess for the future we could attempt upgrading to new versions as well, and I should implement our already existing AppDomains from RustBuster to Fougerite.
Obviously this is not all the full changes but the most important ones. Next update is for RustBuster in some days hopefully. Enjoy this fresh update, should make your server a lot more smoother already!
