Skip to content

Commit 2add55a

Browse files
skuzzissamyycX
skuzzis
and
samyycX
authored
feat(ConVars): Non-generic CVar (#145)
Co-authored-by: samyyc <s1myyc@outlook.com>
1 parent 4101d31 commit 2add55a

File tree

10 files changed

+1250
-950
lines changed

10 files changed

+1250
-950
lines changed

‎managed/src/SwiftlyS2.Core/Modules/Convars/ConVar.cs‎

Lines changed: 465 additions & 317 deletions
Large diffs are not rendered by default.

‎managed/src/SwiftlyS2.Core/Modules/Convars/ConVarService.cs‎

Lines changed: 273 additions & 481 deletions
Large diffs are not rendered by default.

‎managed/src/SwiftlyS2.Core/Services/StartupService.cs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,6 @@ internal class StartupService : IHostedService
1111
public StartupService( IServiceProvider provider )
1212
{
1313
// this.provider = provider;
14-
// provider.UseTestService();
1514
provider.UseCoreHookService();
1615
provider.UsePermissionManager();
1716
provider.UseCommandTrackerService();
@@ -20,6 +19,7 @@ public StartupService( IServiceProvider provider )
2019
provider.UseCoreCommandService();
2120
// Initialize PluginManager after everything is ready
2221
provider.UsePluginManager();
22+
// provider.UseTestService();
2323
}
2424

2525
public Task StartAsync( CancellationToken cancellationToken )

‎managed/src/SwiftlyS2.Core/Services/TestService.cs‎

Lines changed: 12 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -48,27 +48,24 @@ ISwiftlyCore core
4848
_Logger.LogWarning("TestService created");
4949
_Logger.LogWarning("TestService created");
5050

51-
Test2();
51+
Test();
5252
}
5353

5454

5555
public void Test()
5656
{
57-
_Core.Event.OnEntityCreated += (@event) =>
58-
{
59-
var name = _Core.Memory.GetObjectPtrVtableName(@event.Entity.Address);
60-
Console.WriteLine("Entity spawned: " + name);
61-
var hasVtable = _Core.Memory.ObjectPtrHasVtable(@event.Entity.Address + 1);
62-
Console.WriteLine("Has vtable: " + hasVtable);
63-
var vtable = _Core.Memory.ObjectPtrHasBaseClass(@event.Entity.Address, "CBaseEntity");
64-
Console.WriteLine("Has base class: " + vtable);
65-
var handle = _Core.EntitySystem.GetRefEHandle(@event.Entity);
66-
};
67-
// _Core.Event.OnItemServicesCanAcquireHook += (@event) => {
68-
// Console.WriteLine(@event.EconItemView.ItemDefinitionIndex);
57+
_Core.Command.RegisterCommand("tc", (args) => {
58+
var cvar = _Core.ConVar.Find<float>("mp_warmuptime");
6959

70-
// @event.SetAcquireResult(AcquireResult.NotAllowedByProhibition);
71-
// };
60+
// cvar.MinValueAsString
61+
62+
63+
cvar!.ValueAsString = "10";
64+
cvar!.DefaultValueAsString = "50";
65+
cvar!.MaxValueAsString = "100";
66+
cvar!.MinValueAsString = "10";
67+
cvar.ReplicateToClientAsString(0, "10");
68+
});
7269

7370

7471
}

‎managed/src/SwiftlyS2.Generated/Natives/Convars.cs‎

Lines changed: 208 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -663,4 +663,212 @@ public unsafe static void SetValueInternalPtr(string cvarName, nint value) {
663663
pool.Return(cvarNameBuffer);
664664
}
665665
}
666+
667+
private unsafe static delegate* unmanaged<byte*, byte*, byte> _SetValueAsString;
668+
669+
public unsafe static bool SetValueAsString(string cvarName, string value) {
670+
if (Thread.CurrentThread.ManagedThreadId != _MainThreadID) {
671+
throw new InvalidOperationException("This method can only be called from the main thread.");
672+
}
673+
var pool = ArrayPool<byte>.Shared;
674+
var cvarNameLength = Encoding.UTF8.GetByteCount(cvarName);
675+
var cvarNameBuffer = pool.Rent(cvarNameLength + 1);
676+
Encoding.UTF8.GetBytes(cvarName, cvarNameBuffer);
677+
cvarNameBuffer[cvarNameLength] = 0;
678+
var valueLength = Encoding.UTF8.GetByteCount(value);
679+
var valueBuffer = pool.Rent(valueLength + 1);
680+
Encoding.UTF8.GetBytes(value, valueBuffer);
681+
valueBuffer[valueLength] = 0;
682+
fixed (byte* cvarNameBufferPtr = cvarNameBuffer) {
683+
fixed (byte* valueBufferPtr = valueBuffer) {
684+
var ret = _SetValueAsString(cvarNameBufferPtr, valueBufferPtr);
685+
pool.Return(cvarNameBuffer);
686+
pool.Return(valueBuffer);
687+
return ret == 1;
688+
}
689+
}
690+
}
691+
692+
private unsafe static delegate* unmanaged<byte*, byte*, int> _GetValueAsString;
693+
694+
public unsafe static string GetValueAsString(string cvarName) {
695+
var pool = ArrayPool<byte>.Shared;
696+
var cvarNameLength = Encoding.UTF8.GetByteCount(cvarName);
697+
var cvarNameBuffer = pool.Rent(cvarNameLength + 1);
698+
Encoding.UTF8.GetBytes(cvarName, cvarNameBuffer);
699+
cvarNameBuffer[cvarNameLength] = 0;
700+
fixed (byte* cvarNameBufferPtr = cvarNameBuffer) {
701+
var ret = _GetValueAsString(null, cvarNameBufferPtr);
702+
var retBuffer = pool.Rent(ret + 1);
703+
fixed (byte* retBufferPtr = retBuffer) {
704+
ret = _GetValueAsString(retBufferPtr, cvarNameBufferPtr);
705+
var retString = Encoding.UTF8.GetString(retBufferPtr, ret);
706+
pool.Return(retBuffer);
707+
pool.Return(cvarNameBuffer);
708+
return retString;
709+
}
710+
}
711+
}
712+
713+
private unsafe static delegate* unmanaged<byte*, byte*, byte> _SetDefaultValueAsString;
714+
715+
public unsafe static bool SetDefaultValueAsString(string cvarName, string value) {
716+
if (Thread.CurrentThread.ManagedThreadId != _MainThreadID) {
717+
throw new InvalidOperationException("This method can only be called from the main thread.");
718+
}
719+
var pool = ArrayPool<byte>.Shared;
720+
var cvarNameLength = Encoding.UTF8.GetByteCount(cvarName);
721+
var cvarNameBuffer = pool.Rent(cvarNameLength + 1);
722+
Encoding.UTF8.GetBytes(cvarName, cvarNameBuffer);
723+
cvarNameBuffer[cvarNameLength] = 0;
724+
var valueLength = Encoding.UTF8.GetByteCount(value);
725+
var valueBuffer = pool.Rent(valueLength + 1);
726+
Encoding.UTF8.GetBytes(value, valueBuffer);
727+
valueBuffer[valueLength] = 0;
728+
fixed (byte* cvarNameBufferPtr = cvarNameBuffer) {
729+
fixed (byte* valueBufferPtr = valueBuffer) {
730+
var ret = _SetDefaultValueAsString(cvarNameBufferPtr, valueBufferPtr);
731+
pool.Return(cvarNameBuffer);
732+
pool.Return(valueBuffer);
733+
return ret == 1;
734+
}
735+
}
736+
}
737+
738+
private unsafe static delegate* unmanaged<byte*, byte*, int> _GetDefaultValueAsString;
739+
740+
public unsafe static string GetDefaultValueAsString(string cvarName) {
741+
var pool = ArrayPool<byte>.Shared;
742+
var cvarNameLength = Encoding.UTF8.GetByteCount(cvarName);
743+
var cvarNameBuffer = pool.Rent(cvarNameLength + 1);
744+
Encoding.UTF8.GetBytes(cvarName, cvarNameBuffer);
745+
cvarNameBuffer[cvarNameLength] = 0;
746+
fixed (byte* cvarNameBufferPtr = cvarNameBuffer) {
747+
var ret = _GetDefaultValueAsString(null, cvarNameBufferPtr);
748+
var retBuffer = pool.Rent(ret + 1);
749+
fixed (byte* retBufferPtr = retBuffer) {
750+
ret = _GetDefaultValueAsString(retBufferPtr, cvarNameBufferPtr);
751+
var retString = Encoding.UTF8.GetString(retBufferPtr, ret);
752+
pool.Return(retBuffer);
753+
pool.Return(cvarNameBuffer);
754+
return retString;
755+
}
756+
}
757+
}
758+
759+
private unsafe static delegate* unmanaged<byte*, byte*, byte> _SetMinValueAsString;
760+
761+
public unsafe static bool SetMinValueAsString(string cvarName, string value) {
762+
if (Thread.CurrentThread.ManagedThreadId != _MainThreadID) {
763+
throw new InvalidOperationException("This method can only be called from the main thread.");
764+
}
765+
var pool = ArrayPool<byte>.Shared;
766+
var cvarNameLength = Encoding.UTF8.GetByteCount(cvarName);
767+
var cvarNameBuffer = pool.Rent(cvarNameLength + 1);
768+
Encoding.UTF8.GetBytes(cvarName, cvarNameBuffer);
769+
cvarNameBuffer[cvarNameLength] = 0;
770+
var valueLength = Encoding.UTF8.GetByteCount(value);
771+
var valueBuffer = pool.Rent(valueLength + 1);
772+
Encoding.UTF8.GetBytes(value, valueBuffer);
773+
valueBuffer[valueLength] = 0;
774+
fixed (byte* cvarNameBufferPtr = cvarNameBuffer) {
775+
fixed (byte* valueBufferPtr = valueBuffer) {
776+
var ret = _SetMinValueAsString(cvarNameBufferPtr, valueBufferPtr);
777+
pool.Return(cvarNameBuffer);
778+
pool.Return(valueBuffer);
779+
return ret == 1;
780+
}
781+
}
782+
}
783+
784+
private unsafe static delegate* unmanaged<byte*, byte*, int> _GetMinValueAsString;
785+
786+
public unsafe static string GetMinValueAsString(string cvarName) {
787+
var pool = ArrayPool<byte>.Shared;
788+
var cvarNameLength = Encoding.UTF8.GetByteCount(cvarName);
789+
var cvarNameBuffer = pool.Rent(cvarNameLength + 1);
790+
Encoding.UTF8.GetBytes(cvarName, cvarNameBuffer);
791+
cvarNameBuffer[cvarNameLength] = 0;
792+
fixed (byte* cvarNameBufferPtr = cvarNameBuffer) {
793+
var ret = _GetMinValueAsString(null, cvarNameBufferPtr);
794+
var retBuffer = pool.Rent(ret + 1);
795+
fixed (byte* retBufferPtr = retBuffer) {
796+
ret = _GetMinValueAsString(retBufferPtr, cvarNameBufferPtr);
797+
var retString = Encoding.UTF8.GetString(retBufferPtr, ret);
798+
pool.Return(retBuffer);
799+
pool.Return(cvarNameBuffer);
800+
return retString;
801+
}
802+
}
803+
}
804+
805+
private unsafe static delegate* unmanaged<byte*, byte*, byte> _SetMaxValueAsString;
806+
807+
public unsafe static bool SetMaxValueAsString(string cvarName, string value) {
808+
if (Thread.CurrentThread.ManagedThreadId != _MainThreadID) {
809+
throw new InvalidOperationException("This method can only be called from the main thread.");
810+
}
811+
var pool = ArrayPool<byte>.Shared;
812+
var cvarNameLength = Encoding.UTF8.GetByteCount(cvarName);
813+
var cvarNameBuffer = pool.Rent(cvarNameLength + 1);
814+
Encoding.UTF8.GetBytes(cvarName, cvarNameBuffer);
815+
cvarNameBuffer[cvarNameLength] = 0;
816+
var valueLength = Encoding.UTF8.GetByteCount(value);
817+
var valueBuffer = pool.Rent(valueLength + 1);
818+
Encoding.UTF8.GetBytes(value, valueBuffer);
819+
valueBuffer[valueLength] = 0;
820+
fixed (byte* cvarNameBufferPtr = cvarNameBuffer) {
821+
fixed (byte* valueBufferPtr = valueBuffer) {
822+
var ret = _SetMaxValueAsString(cvarNameBufferPtr, valueBufferPtr);
823+
pool.Return(cvarNameBuffer);
824+
pool.Return(valueBuffer);
825+
return ret == 1;
826+
}
827+
}
828+
}
829+
830+
private unsafe static delegate* unmanaged<byte*, byte*, int> _GetMaxValueAsString;
831+
832+
public unsafe static string GetMaxValueAsString(string cvarName) {
833+
var pool = ArrayPool<byte>.Shared;
834+
var cvarNameLength = Encoding.UTF8.GetByteCount(cvarName);
835+
var cvarNameBuffer = pool.Rent(cvarNameLength + 1);
836+
Encoding.UTF8.GetBytes(cvarName, cvarNameBuffer);
837+
cvarNameBuffer[cvarNameLength] = 0;
838+
fixed (byte* cvarNameBufferPtr = cvarNameBuffer) {
839+
var ret = _GetMaxValueAsString(null, cvarNameBufferPtr);
840+
var retBuffer = pool.Rent(ret + 1);
841+
fixed (byte* retBufferPtr = retBuffer) {
842+
ret = _GetMaxValueAsString(retBufferPtr, cvarNameBufferPtr);
843+
var retString = Encoding.UTF8.GetString(retBufferPtr, ret);
844+
pool.Return(retBuffer);
845+
pool.Return(cvarNameBuffer);
846+
return retString;
847+
}
848+
}
849+
}
850+
851+
private unsafe static delegate* unmanaged<byte*, byte*, void> _SetValueInternalAsString;
852+
853+
public unsafe static void SetValueInternalAsString(string cvarName, string value) {
854+
if (Thread.CurrentThread.ManagedThreadId != _MainThreadID) {
855+
throw new InvalidOperationException("This method can only be called from the main thread.");
856+
}
857+
var pool = ArrayPool<byte>.Shared;
858+
var cvarNameLength = Encoding.UTF8.GetByteCount(cvarName);
859+
var cvarNameBuffer = pool.Rent(cvarNameLength + 1);
860+
Encoding.UTF8.GetBytes(cvarName, cvarNameBuffer);
861+
cvarNameBuffer[cvarNameLength] = 0;
862+
var valueLength = Encoding.UTF8.GetByteCount(value);
863+
var valueBuffer = pool.Rent(valueLength + 1);
864+
Encoding.UTF8.GetBytes(value, valueBuffer);
865+
valueBuffer[valueLength] = 0;
866+
fixed (byte* cvarNameBufferPtr = cvarNameBuffer) {
867+
fixed (byte* valueBufferPtr = valueBuffer) {
868+
_SetValueInternalAsString(cvarNameBufferPtr, valueBufferPtr);
869+
pool.Return(cvarNameBuffer);
870+
pool.Return(valueBuffer);
871+
}
872+
}
873+
}
666874
}

0 commit comments

Comments
 (0)