Merge remote-tracking branch 'upstream/beta' into beta-1

Author: ELDment

managed/src/SwiftlyS2.Generated/Protobufs/Classes/CDemoFileHeaderImpl.cs

@@ -18,8 +18,8 @@ public string DemoFileStamp
   { get => Accessor.GetString("demo_file_stamp"); set => Accessor.SetString("demo_file_stamp", value); }
 
 
-  public int NetworkProtocol
-  { get => Accessor.GetInt32("network_protocol"); set => Accessor.SetInt32("network_protocol", value); }
+  public int PatchVersion
+  { get => Accessor.GetInt32("patch_version"); set => Accessor.SetInt32("patch_version", value); }
 
 
   public string ServerName

managed/src/SwiftlyS2.Generated/Protobufs/Classes/CMsgTEFireBulletsImpl.cs

@@ -73,4 +73,8 @@ public uint NumBulletsRemaining
   public uint AttackType
   { get => Accessor.GetUInt32("attack_type"); set => Accessor.SetUInt32("attack_type", value); }
 
+
+  public CMsgTEFireBullets_Extra Extra
+  { get => new CMsgTEFireBullets_ExtraImpl(NativeNetMessages.GetNestedMessage(Address, "extra"), false); }
+
 }

managed/src/SwiftlyS2.Generated/Protobufs/Classes/CMsgTEFireBullets_ExtraImpl.cs

@@ -0,0 +1,48 @@
+
+using SwiftlyS2.Core.Natives;
+using SwiftlyS2.Core.NetMessages;
+using SwiftlyS2.Shared.Natives;
+using SwiftlyS2.Shared.NetMessages;
+using SwiftlyS2.Shared.ProtobufDefinitions;
+
+namespace SwiftlyS2.Core.ProtobufDefinitions;
+
+internal class CMsgTEFireBullets_ExtraImpl : TypedProtobuf<CMsgTEFireBullets_Extra>, CMsgTEFireBullets_Extra
+{
+  public CMsgTEFireBullets_ExtraImpl(nint handle, bool isManuallyAllocated): base(handle)
+  {
+  }
+
+
+  public QAngle AimPunch
+  { get => Accessor.GetQAngle("aim_punch"); set => Accessor.SetQAngle("aim_punch", value); }
+
+
+  public int AttackTickCount
+  { get => Accessor.GetInt32("attack_tick_count"); set => Accessor.SetInt32("attack_tick_count", value); }
+
+
+  public float AttackTickFrac
+  { get => Accessor.GetFloat("attack_tick_frac"); set => Accessor.SetFloat("attack_tick_frac", value); }
+
+
+  public int RenderTickCount
+  { get => Accessor.GetInt32("render_tick_count"); set => Accessor.SetInt32("render_tick_count", value); }
+
+
+  public float RenderTickFrac
+  { get => Accessor.GetFloat("render_tick_frac"); set => Accessor.SetFloat("render_tick_frac", value); }
+
+
+  public float InaccuracyMove
+  { get => Accessor.GetFloat("inaccuracy_move"); set => Accessor.SetFloat("inaccuracy_move", value); }
+
+
+  public float InaccuracyAir
+  { get => Accessor.GetFloat("inaccuracy_air"); set => Accessor.SetFloat("inaccuracy_air", value); }
+
+
+  public int Type
+  { get => Accessor.GetInt32("type"); set => Accessor.SetInt32("type", value); }
+
+}

managed/src/SwiftlyS2.Generated/Protobufs/Classes/CSVCMsg_NextMsgPredictedImpl.cs

@@ -0,0 +1,24 @@
+
+using SwiftlyS2.Core.Natives;
+using SwiftlyS2.Core.NetMessages;
+using SwiftlyS2.Shared.Natives;
+using SwiftlyS2.Shared.NetMessages;
+using SwiftlyS2.Shared.ProtobufDefinitions;
+
+namespace SwiftlyS2.Core.ProtobufDefinitions;
+
+internal class CSVCMsg_NextMsgPredictedImpl : NetMessage<CSVCMsg_NextMsgPredicted>, CSVCMsg_NextMsgPredicted
+{
+  public CSVCMsg_NextMsgPredictedImpl(nint handle, bool isManuallyAllocated): base(handle, isManuallyAllocated)
+  {
+  }
+
+
+  public int PredictedByPlayerSlot
+  { get => Accessor.GetInt32("predicted_by_player_slot"); set => Accessor.SetInt32("predicted_by_player_slot", value); }
+
+
+  public uint MessageTypeId
+  { get => Accessor.GetUInt32("message_type_id"); set => Accessor.SetUInt32("message_type_id", value); }
+
+}

managed/src/SwiftlyS2.Generated/Protobufs/Enums/SVC_Messages.cs

@@ -33,4 +33,5 @@ public enum SVC_Messages
   svc_Broadcast_Command = 74,
   svc_HltvFixupOperatorStatus = 75,
   svc_UserCmds = 76,
+  svc_NextMsgPredicted = 77,
 }

managed/src/SwiftlyS2.Generated/Protobufs/Interfaces/CDemoFileHeader.cs

@@ -13,7 +13,7 @@ public interface CDemoFileHeader : ITypedProtobuf<CDemoFileHeader>
   public string DemoFileStamp { get; set; }
 
 
-  public int NetworkProtocol { get; set; }
+  public int PatchVersion { get; set; }
 
 
   public string ServerName { get; set; }

managed/src/SwiftlyS2.Generated/Protobufs/Interfaces/CMsgTEFireBullets.cs

@@ -59,4 +59,7 @@ public interface CMsgTEFireBullets : ITypedProtobuf<CMsgTEFireBullets>, INetMess
 
   public uint AttackType { get; set; }
 
+
+  public CMsgTEFireBullets_Extra Extra { get; }
+
 }

managed/src/SwiftlyS2.Generated/Protobufs/Interfaces/CMsgTEFireBullets_Extra.cs

@@ -0,0 +1,36 @@
+
+using SwiftlyS2.Core.ProtobufDefinitions;
+using SwiftlyS2.Shared.Natives;
+using SwiftlyS2.Shared.NetMessages;
+
+namespace SwiftlyS2.Shared.ProtobufDefinitions;
+
+public interface CMsgTEFireBullets_Extra : ITypedProtobuf<CMsgTEFireBullets_Extra>
+{
+  static CMsgTEFireBullets_Extra ITypedProtobuf<CMsgTEFireBullets_Extra>.Wrap(nint handle, bool isManuallyAllocated) => new CMsgTEFireBullets_ExtraImpl(handle, isManuallyAllocated);
+
+
+  public QAngle AimPunch { get; set; }
+
+
+  public int AttackTickCount { get; set; }
+
+
+  public float AttackTickFrac { get; set; }
+
+
+  public int RenderTickCount { get; set; }
+
+
+  public float RenderTickFrac { get; set; }
+
+
+  public float InaccuracyMove { get; set; }
+
+
+  public float InaccuracyAir { get; set; }
+
+
+  public int Type { get; set; }
+
+}

managed/src/SwiftlyS2.Generated/Protobufs/Interfaces/CSVCMsg_NextMsgPredicted.cs

@@ -0,0 +1,23 @@
+
+using SwiftlyS2.Core.ProtobufDefinitions;
+using SwiftlyS2.Shared.Natives;
+using SwiftlyS2.Shared.NetMessages;
+
+namespace SwiftlyS2.Shared.ProtobufDefinitions;
+using SwiftlyS2.Shared.NetMessages;
+
+public interface CSVCMsg_NextMsgPredicted : ITypedProtobuf<CSVCMsg_NextMsgPredicted>, INetMessage<CSVCMsg_NextMsgPredicted>, IDisposable
+{
+  static int INetMessage<CSVCMsg_NextMsgPredicted>.MessageId => 77;
+  
+  static string INetMessage<CSVCMsg_NextMsgPredicted>.MessageName => "CSVCMsg_NextMsgPredicted";
+
+  static CSVCMsg_NextMsgPredicted ITypedProtobuf<CSVCMsg_NextMsgPredicted>.Wrap(nint handle, bool isManuallyAllocated) => new CSVCMsg_NextMsgPredictedImpl(handle, isManuallyAllocated);
+
+
+  public int PredictedByPlayerSlot { get; set; }
+
+
+  public uint MessageTypeId { get; set; }
+
+}

managed/src/SwiftlyS2.Shared/Natives/Structs/CRecipientFilter.cs

@@ -132,11 +132,19 @@ public unsafe static bool IsInitMessage( CRecipientFilter* filter )
     }
 
     [UnmanagedCallersOnly]
-    public unsafe static int GetPredictedSlot( CRecipientFilter* filter )
+    public unsafe static int* GetPredictedSlotWindows( CRecipientFilter* filter, int* pPlayerSlot )
+    {
+        *pPlayerSlot = filter->PredictedSlot;
+        return pPlayerSlot;
+    }
+
+    [UnmanagedCallersOnly]
+    public unsafe static int GetPredictedSlotLinux( CRecipientFilter* filter )
     {
         return filter->PredictedSlot;
     }
 
+
     static unsafe CRecipientFilterVtable()
     {
         pCRecipientFilterVTable = Marshal.AllocHGlobal(sizeof(nint) * 5);
@@ -145,6 +153,13 @@ static unsafe CRecipientFilterVtable()
         vtable[1] = (nint)(delegate* unmanaged< CRecipientFilter*, NetChannelBufType_t >)(&GetNetworkBufType);
         vtable[2] = (nint)(delegate* unmanaged< CRecipientFilter*, bool >)(&IsInitMessage);
         vtable[3] = (nint)(delegate* unmanaged< CRecipientFilter*, ulong* >)(&GetRecipients);
-        vtable[4] = (nint)(delegate* unmanaged< CRecipientFilter*, int >)(&GetPredictedSlot);
+        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
+        {
+            vtable[4] = (nint)(delegate* unmanaged< CRecipientFilter*, int*, int* >)(&GetPredictedSlotWindows);
+        }
+        else
+        {
+            vtable[4] = (nint)(delegate* unmanaged< CRecipientFilter*, int >)(&GetPredictedSlotLinux);
+        }
     }
 }