From c332b89bf775d6deec30924b28e4c77c59f0c142 Mon Sep 17 00:00:00 2001
From: EntenKoeniq <81123713+EntenKoeniq@users.noreply.github.com>
Date: Wed, 7 Jul 2021 13:36:25 +0200
Subject: [PATCH] Initial commit
---
.gitattributes | 2 +
.github/FUNDING.yml | 1 +
.gitignore | 4 +
Client/Chat.cs | 143 +++++++
Client/CoopClient.csproj | 85 +++++
Client/Entities/EntitiesNPC.cs | 7 +
Client/Entities/EntitiesPed.cs | 354 ++++++++++++++++++
Client/Entities/EntitiesPlayer.cs | 8 +
Client/Entities/EntitiesThread.cs | 62 ++++
Client/Main.cs | 362 ++++++++++++++++++
Client/Networking.cs | 556 ++++++++++++++++++++++++++++
Client/Packets.cs | 478 ++++++++++++++++++++++++
Client/PlayerList.cs | 47 +++
Client/Properties/AssemblyInfo.cs | 36 ++
Client/Settings.cs | 9 +
Client/Util.cs | 189 ++++++++++
Client/WorldThread.cs | 26 ++
Client/packages.config | 4 +
GTACoop.sln | 31 ++
Images/LOGO.png | Bin 0 -> 108876 bytes
LICENSE | 21 ++
Libs/Release/LemonUI.SHVDN3.dll | Bin 0 -> 72704 bytes
Libs/Release/Lidgren.Network.dll | Bin 0 -> 119296 bytes
Libs/Release/ScriptHookVDotNet3.dll | Bin 0 -> 867328 bytes
MasterServer/blocked.txt | 0
MasterServer/index.mjs | 86 +++++
MasterServer/package.json | 11 +
README.md | 45 +++
Server/Allowlist.cs | 9 +
Server/Blocklist.cs | 11 +
Server/CoopServer.csproj | 18 +
Server/Entities/EntitiesPed.cs | 12 +
Server/Entities/EntitiesPlayer.cs | 9 +
Server/Logging.cs | 79 ++++
Server/Packets.cs | 459 +++++++++++++++++++++++
Server/Program.cs | 28 ++
Server/Server.cs | 500 +++++++++++++++++++++++++
Server/Settings.cs | 15 +
Server/Util.cs | 36 ++
39 files changed, 3743 insertions(+)
create mode 100644 .gitattributes
create mode 100644 .github/FUNDING.yml
create mode 100644 .gitignore
create mode 100644 Client/Chat.cs
create mode 100644 Client/CoopClient.csproj
create mode 100644 Client/Entities/EntitiesNPC.cs
create mode 100644 Client/Entities/EntitiesPed.cs
create mode 100644 Client/Entities/EntitiesPlayer.cs
create mode 100644 Client/Entities/EntitiesThread.cs
create mode 100644 Client/Main.cs
create mode 100644 Client/Networking.cs
create mode 100644 Client/Packets.cs
create mode 100644 Client/PlayerList.cs
create mode 100644 Client/Properties/AssemblyInfo.cs
create mode 100644 Client/Settings.cs
create mode 100644 Client/Util.cs
create mode 100644 Client/WorldThread.cs
create mode 100644 Client/packages.config
create mode 100644 GTACoop.sln
create mode 100644 Images/LOGO.png
create mode 100644 LICENSE
create mode 100644 Libs/Release/LemonUI.SHVDN3.dll
create mode 100644 Libs/Release/Lidgren.Network.dll
create mode 100644 Libs/Release/ScriptHookVDotNet3.dll
create mode 100644 MasterServer/blocked.txt
create mode 100644 MasterServer/index.mjs
create mode 100644 MasterServer/package.json
create mode 100644 README.md
create mode 100644 Server/Allowlist.cs
create mode 100644 Server/Blocklist.cs
create mode 100644 Server/CoopServer.csproj
create mode 100644 Server/Entities/EntitiesPed.cs
create mode 100644 Server/Entities/EntitiesPlayer.cs
create mode 100644 Server/Logging.cs
create mode 100644 Server/Packets.cs
create mode 100644 Server/Program.cs
create mode 100644 Server/Server.cs
create mode 100644 Server/Settings.cs
create mode 100644 Server/Util.cs
diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 0000000..dfe0770
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto
diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
new file mode 100644
index 0000000..b9de1ab
--- /dev/null
+++ b/.github/FUNDING.yml
@@ -0,0 +1 @@
+custom: ['https://spenden.pp-h.eu/68454276-da3c-47c7-b95a-7fa443706a44']
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..08f611d
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,4 @@
+**/bin
+**/obj
+**/packages
+.vs/*
\ No newline at end of file
diff --git a/Client/Chat.cs b/Client/Chat.cs
new file mode 100644
index 0000000..905a935
--- /dev/null
+++ b/Client/Chat.cs
@@ -0,0 +1,143 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Windows.Forms;
+
+using GTA;
+using GTA.Native;
+
+namespace CoopClient
+{
+ public class Chat
+ {
+ private readonly Scaleform MainScaleForm;
+
+ public string CurrentInput { get; set; }
+
+ private bool CurrentFocused { get; set; }
+ public bool Focused
+ {
+ get { return CurrentFocused; }
+ set
+ {
+ MainScaleForm.CallFunction("SET_FOCUS", value ? 2 : 1, 2, "ALL");
+
+ CurrentFocused = value;
+ }
+ }
+
+ public Chat()
+ {
+ MainScaleForm = new Scaleform("multiplayer_chat");
+ }
+
+ public void Init()
+ {
+ MainScaleForm.CallFunction("SET_FOCUS", 2, 2, "ALL");
+ MainScaleForm.CallFunction("SET_FOCUS", 1, 2, "ALL");
+ }
+
+ public void Clear()
+ {
+ MainScaleForm.CallFunction("RESET");
+ }
+
+ public void Tick()
+ {
+ MainScaleForm.Render2D();
+
+ if (!CurrentFocused)
+ {
+ return;
+ }
+
+ Function.Call(Hash.DISABLE_ALL_CONTROL_ACTIONS, 0);
+ }
+
+ public void AddMessage(string sender, string msg)
+ {
+ MainScaleForm.CallFunction("ADD_MESSAGE", sender + ":", msg);
+ }
+
+ public void OnKeyDown(Keys key)
+ {
+ if (key == Keys.Escape)
+ {
+ Focused = false;
+ CurrentInput = "";
+ return;
+ }
+
+ if (key == Keys.PageUp)
+ {
+ MainScaleForm.CallFunction("PAGE_UP");
+ }
+ else if (key == Keys.PageDown)
+ {
+ MainScaleForm.CallFunction("PAGE_DOWN");
+ }
+
+ string keyChar = GetCharFromKey(key, Game.IsKeyPressed(Keys.ShiftKey), false);
+
+ if (keyChar.Length == 0)
+ {
+ return;
+ }
+
+ switch (keyChar[0])
+ {
+ case (char)8:
+ if (CurrentInput.Length > 0)
+ {
+ MainScaleForm.CallFunction("SET_FOCUS", 1, 2, "ALL");
+ MainScaleForm.CallFunction("SET_FOCUS", 2, 2, "ALL");
+
+ CurrentInput = CurrentInput.Substring(0, CurrentInput.Length - 1);
+ MainScaleForm.CallFunction("ADD_TEXT", CurrentInput);
+ }
+ return;
+ case (char)13:
+ MainScaleForm.CallFunction("ADD_TEXT", "ENTER");
+
+ if (!string.IsNullOrWhiteSpace(CurrentInput))
+ {
+ Main.MainNetworking.SendChatMessage(CurrentInput);
+ }
+
+ Focused = false;
+ CurrentInput = "";
+ return;
+ default:
+ CurrentInput += keyChar;
+ MainScaleForm.CallFunction("ADD_TEXT", keyChar);
+ return;
+ }
+ }
+
+ [DllImport("user32.dll")]
+ public static extern int ToUnicodeEx(uint virtualKeyCode, uint scanCode, byte[] keyboardState,
+ [Out, MarshalAs(UnmanagedType.LPWStr, SizeConst = 64)]
+ StringBuilder receivingBuffer,
+ int bufferSize, uint flags, IntPtr kblayout);
+
+ public static string GetCharFromKey(Keys key, bool shift, bool altGr)
+ {
+ StringBuilder buf = new StringBuilder(256);
+ byte[] keyboardState = new byte[256];
+
+ if (shift)
+ {
+ keyboardState[(int)Keys.ShiftKey] = 0xff;
+ }
+
+ if (altGr)
+ {
+ keyboardState[(int)Keys.ControlKey] = 0xff;
+ keyboardState[(int)Keys.Menu] = 0xff;
+ }
+
+ ToUnicodeEx((uint)key, 0, keyboardState, buf, 256, 0, InputLanguage.CurrentInputLanguage.Handle);
+ return buf.ToString();
+ }
+ }
+}
diff --git a/Client/CoopClient.csproj b/Client/CoopClient.csproj
new file mode 100644
index 0000000..121b9e6
--- /dev/null
+++ b/Client/CoopClient.csproj
@@ -0,0 +1,85 @@
+
+
+
+
+ Debug
+ AnyCPU
+ {EF56D109-1F22-43E0-9DFF-CFCFB94E0681}
+ Library
+ Properties
+ CoopClient
+ CoopClient
+ v4.8
+ 512
+ true
+
+
+
+ true
+ full
+ false
+ bin\Debug\
+ DEBUG;TRACE
+ prompt
+ 4
+ x64
+ true
+
+
+ pdbonly
+ true
+ bin\Release\
+ TRACE
+ prompt
+ 4
+ true
+
+
+
+ ..\Libs\Release\LemonUI.SHVDN3.dll
+
+
+ ..\Libs\Release\Lidgren.Network.dll
+
+
+ ..\packages\protobuf-net.2.4.6\lib\net40\protobuf-net.dll
+
+
+ False
+ ..\Libs\Release\ScriptHookVDotNet3.dll
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/Client/Entities/EntitiesNPC.cs b/Client/Entities/EntitiesNPC.cs
new file mode 100644
index 0000000..560888c
--- /dev/null
+++ b/Client/Entities/EntitiesNPC.cs
@@ -0,0 +1,7 @@
+namespace CoopClient.Entities
+{
+ public class EntitiesNpc : EntitiesPed
+ {
+ public int LastUpdateReceived { get; set; }
+ }
+}
diff --git a/Client/Entities/EntitiesPed.cs b/Client/Entities/EntitiesPed.cs
new file mode 100644
index 0000000..480f9b0
--- /dev/null
+++ b/Client/Entities/EntitiesPed.cs
@@ -0,0 +1,354 @@
+using System;
+using System.Drawing;
+using System.Collections.Generic;
+
+using GTA;
+using GTA.Native;
+using GTA.Math;
+
+using LemonUI.Elements;
+
+namespace CoopClient
+{
+ public class EntitiesPed
+ {
+ private bool AllDataAvailable = false;
+ public bool LastSyncWasFull { get; set; } = false;
+
+ public Ped Character { get; set; }
+ public int Health { get; set; }
+ private int LastModelHash = 0;
+ public int ModelHash { get; set; }
+ private Dictionary LastProps = new Dictionary();
+ public Dictionary Props { get; set; }
+ public Vector3 Position { get; set; }
+ public Vector3 Rotation { get; set; }
+ public Vector3 Velocity { get; set; }
+ public byte Speed { get; set; }
+ private bool LastIsJumping = false;
+ public bool IsJumping { get; set; }
+ public bool IsRagdoll { get; set; }
+ public bool IsOnFire { get; set; }
+ public Vector3 AimCoords { get; set; }
+ public bool IsAiming { get; set; }
+ public bool IsShooting { get; set; }
+ public bool IsReloading { get; set; }
+ public int CurrentWeaponHash { get; set; }
+
+ private Blip PedBlip;
+
+ public void DisplayLocally(string username)
+ {
+ /*
+ * username: string
+ * string: null
+ * ped: npc
+ * string: value
+ * ped: player
+ */
+
+ // Check beforehand whether ped has all the required data
+ if (!AllDataAvailable)
+ {
+ if (!LastSyncWasFull)
+ {
+ return;
+ }
+
+ AllDataAvailable = true;
+ }
+
+ #region NOT_IN_RANGE
+ if (!Game.Player.Character.IsInRange(Position, 250f))
+ {
+ if (Character != null && Character.Exists())
+ {
+ Character.Kill();
+ Character.Delete();
+ }
+
+ if (username != null)
+ {
+ if (PedBlip == null || !PedBlip.Exists())
+ {
+ PedBlip = World.CreateBlip(Position);
+ PedBlip.Color = BlipColor.White;
+ PedBlip.Scale = 0.8f;
+ PedBlip.Name = username;
+ }
+ else
+ {
+ PedBlip.Position = Position;
+ }
+ }
+
+ return;
+ }
+ #endregion
+
+ #region IS_IN_RANGE
+ if (PedBlip != null && PedBlip.Exists())
+ {
+ PedBlip.Delete();
+ }
+
+ bool characterExist = Character != null && Character.Exists();
+
+ if (!characterExist)
+ {
+ CreateCharacter(username);
+ }
+ else if (LastSyncWasFull)
+ {
+ if (ModelHash != LastModelHash)
+ {
+ if (characterExist)
+ {
+ Character.Kill();
+ Character.Delete();
+ }
+
+ CreateCharacter(username);
+ }
+ else if (Props != LastProps)
+ {
+ foreach (KeyValuePair prop in Props)
+ {
+ Function.Call(Hash.SET_PED_COMPONENT_VARIATION, Character.Handle, prop.Key, prop.Value, 0, 0);
+ }
+
+ LastProps = Props;
+ }
+ }
+
+ if (username != null && Character.IsInRange(Game.Player.Character.Position, 20f))
+ {
+ float sizeOffset;
+ if (GameplayCamera.IsFirstPersonAimCamActive)
+ {
+ Vector3 targetPos = Character.Bones[Bone.IKHead].Position + new Vector3(0, 0, 0.10f) + (Character.Velocity / Game.FPS);
+
+ Function.Call(Hash.SET_DRAW_ORIGIN, targetPos.X, targetPos.Y, targetPos.Z, 0);
+
+ sizeOffset = Math.Max(1f - ((GameplayCamera.Position - Character.Position).Length() / 30f), 0.30f);
+ }
+ else
+ {
+ Vector3 targetPos = Character.Bones[Bone.IKHead].Position + new Vector3(0, 0, 0.35f) + (Character.Velocity / Game.FPS);
+
+ Function.Call(Hash.SET_DRAW_ORIGIN, targetPos.X, targetPos.Y, targetPos.Z, 0);
+
+ sizeOffset = Math.Max(1f - ((GameplayCamera.Position - Character.Position).Length() / 25f), 0.25f);
+ }
+
+ new ScaledText(new PointF(0, 0), username, 0.4f * sizeOffset, GTA.UI.Font.ChaletLondon)
+ {
+ Outline = true,
+ Alignment = GTA.UI.Alignment.Center
+ }.Draw();
+
+ Function.Call(Hash.CLEAR_DRAW_ORIGIN);
+ }
+
+ if (IsOnFire && !Character.IsOnFire)
+ {
+ Character.IsInvincible = false;
+
+ Function.Call(Hash.START_ENTITY_FIRE, Character);
+ }
+ else if (!IsOnFire && Character.IsOnFire)
+ {
+ Function.Call(Hash.STOP_ENTITY_FIRE, Character);
+
+ Character.IsInvincible = true;
+
+ if (Character.IsDead)
+ {
+ Character.Resurrect();
+ }
+ }
+
+ if (Character.IsDead)
+ {
+ if (Health <= 0)
+ {
+ return;
+ }
+
+ Character.IsInvincible = true;
+ Character.Resurrect();
+ }
+ else if (Character.Health != Health)
+ {
+ Character.Health = Health;
+
+ if (Health <= 0 && !Character.IsDead)
+ {
+ Character.IsInvincible = false;
+ Character.Kill();
+ return;
+ }
+ }
+
+ if (IsJumping && !LastIsJumping)
+ {
+ Character.Task.Jump();
+ }
+
+ LastIsJumping = IsJumping;
+
+ if (IsRagdoll && !Character.IsRagdoll)
+ {
+ Character.CanRagdoll = true;
+ Character.Ragdoll();
+
+ return;
+ }
+ else if (!IsRagdoll && Character.IsRagdoll)
+ {
+ Character.CancelRagdoll();
+ Character.CanRagdoll = false;
+ }
+
+ if (IsJumping || IsOnFire)
+ {
+ return;
+ }
+
+ if (IsReloading && !Character.IsReloading)
+ {
+ Character.Task.ClearAll();
+ Character.Task.ReloadWeapon();
+ }
+
+ if (IsReloading)
+ {
+ return;
+ }
+
+ if (Character.Weapons.Current.Hash != (WeaponHash)CurrentWeaponHash)
+ {
+ Character.Weapons.RemoveAll();
+ Character.Weapons.Give((WeaponHash)CurrentWeaponHash, -1, true, true);
+ }
+
+ if (IsShooting)
+ {
+ Function.Call(Hash.SET_PED_INFINITE_AMMO_CLIP, Character, true);
+
+ if (!Character.IsInRange(Position, 0.5f))
+ {
+ Function.Call(Hash.TASK_GO_TO_COORD_WHILE_AIMING_AT_COORD, Character, Position.X, Position.Y,
+ Position.Z, AimCoords.X, AimCoords.Y, AimCoords.Z, 3f, true, 2f, 2f, false, 0, false,
+ unchecked((int)FiringPattern.FullAuto));
+ }
+ else
+ {
+ Function.Call(Hash.TASK_SHOOT_AT_COORD, Character, AimCoords.X, AimCoords.Y, AimCoords.Z, 1500, (uint)FiringPattern.FullAuto);
+ }
+ }
+ else if (IsAiming)
+ {
+ if (!Character.IsInRange(Position, 0.5f))
+ {
+ Function.Call(Hash.TASK_GO_TO_COORD_WHILE_AIMING_AT_COORD, Character, Position.X, Position.Y,
+ Position.Z, AimCoords.X, AimCoords.Y, AimCoords.Z, 3f, false, 2f, 2f, false, 512, false,
+ unchecked((int)FiringPattern.FullAuto));
+ }
+ else
+ {
+ Character.Task.AimAt(AimCoords, -1);
+ }
+ }
+ else
+ {
+ WalkTo();
+ }
+ #endregion
+ }
+
+ private void CreateCharacter(string username)
+ {
+ LastModelHash = ModelHash;
+ LastProps = Props;
+
+ Character = World.CreatePed(new Model(ModelHash), Position, Rotation.Z);
+ Character.RelationshipGroup = Main.RelationshipGroup;
+ Character.BlockPermanentEvents = true;
+ Character.CanRagdoll = false;
+ Character.IsInvincible = true;
+ Character.Health = Health;
+
+ if (username != null)
+ {
+ // Add a new blip for the ped
+ Character.AddBlip();
+ Character.AttachedBlip.Color = BlipColor.White;
+ Character.AttachedBlip.Scale = 0.8f;
+ Character.AttachedBlip.Name = username;
+ }
+
+ foreach (KeyValuePair prop in Props)
+ {
+ Function.Call(Hash.SET_PED_COMPONENT_VARIATION, Character.Handle, prop.Key, prop.Value, 0, 0);
+ }
+ }
+
+ private bool LastMoving;
+ private void WalkTo()
+ {
+ if (!Character.IsInRange(Position, 7.0f) && (LastMoving = true))
+ {
+ Character.Position = Position;
+ Character.Rotation = Rotation;
+ }
+ else
+ {
+ Vector3 predictPosition = Position + (Position - Character.Position) + Velocity;
+ float range = predictPosition.DistanceToSquared(Character.Position);
+
+ switch (Speed)
+ {
+ case 1:
+ if ((!Character.IsWalking || range > 0.25f) && (LastMoving = true))
+ {
+ float nrange = range * 2;
+ if (nrange > 1.0f)
+ {
+ nrange = 1.0f;
+ }
+
+ Character.Task.GoStraightTo(predictPosition);
+ Function.Call(Hash.SET_PED_DESIRED_MOVE_BLEND_RATIO, Character, nrange);
+ }
+ break;
+ case 2:
+ if ((!Character.IsRunning || range > 0.50f) && (LastMoving = true))
+ {
+ Character.Task.RunTo(predictPosition, true);
+ Function.Call(Hash.SET_PED_DESIRED_MOVE_BLEND_RATIO, Character, 1.0f);
+ }
+ break;
+ case 3:
+ if ((!Character.IsSprinting || range > 0.75f) && (LastMoving = true))
+ {
+ Function.Call(Hash.TASK_GO_STRAIGHT_TO_COORD, Character, predictPosition.X, predictPosition.Y, predictPosition.Z, 3.0f, -1, 0.0f, 0.0f);
+ Function.Call(Hash.SET_RUN_SPRINT_MULTIPLIER_FOR_PLAYER, Character, 1.49f);
+ Function.Call(Hash.SET_PED_DESIRED_MOVE_BLEND_RATIO, Character, 1.0f);
+ }
+ break;
+ default:
+ if (!Character.IsInRange(Position, 0.5f))
+ {
+ Character.Task.RunTo(Position, true, 500);
+ }
+ else if (LastMoving && (LastMoving = false))
+ {
+ Character.Task.StandStill(2000);
+ }
+ break;
+ }
+ }
+ }
+ }
+}
diff --git a/Client/Entities/EntitiesPlayer.cs b/Client/Entities/EntitiesPlayer.cs
new file mode 100644
index 0000000..d520161
--- /dev/null
+++ b/Client/Entities/EntitiesPlayer.cs
@@ -0,0 +1,8 @@
+namespace CoopClient.Entities
+{
+ public class EntitiesPlayer : EntitiesPed
+ {
+ public string SocialClubName { get; set; }
+ public string Username { get; set; } = "Player";
+ }
+}
diff --git a/Client/Entities/EntitiesThread.cs b/Client/Entities/EntitiesThread.cs
new file mode 100644
index 0000000..547606e
--- /dev/null
+++ b/Client/Entities/EntitiesThread.cs
@@ -0,0 +1,62 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+using GTA;
+
+namespace CoopClient.Entities
+{
+ public class EntitiesThread : Script
+ {
+ const int npcThreshold = 2500; // 2.5 seconds timeout
+
+ public EntitiesThread()
+ {
+ Tick += OnTick;
+ Interval = 1000 / 60;
+ }
+
+ private void OnTick(object sender, EventArgs e)
+ {
+ if (Game.IsLoading || !Main.MainNetworking.IsOnServer() || !Main.NpcsAllowed)
+ {
+ return;
+ }
+
+ lock (Main.Npcs)
+ {
+ // Remove all NPCs with a last update older than npcThreshold or display this npc
+ foreach (KeyValuePair npc in new Dictionary(Main.Npcs))
+ {
+ if ((Environment.TickCount - npc.Value.LastUpdateReceived) > npcThreshold)
+ {
+ if (npc.Value.Character != null && npc.Value.Character.Exists() && npc.Value.Health > 0)
+ {
+ npc.Value.Character.Kill();
+ npc.Value.Character.Delete();
+ }
+
+ Main.Npcs.Remove(npc.Key);
+ }
+ else
+ {
+ npc.Value.DisplayLocally(null);
+ }
+ }
+ }
+
+ // Only if that player wants to share his NPCs with others
+ if (Main.ShareNpcsWithPlayers)
+ {
+ // Send all npcs from the current player
+ foreach (Ped ped in World.GetNearbyPeds(Game.Player.Character.Position, 150f)
+ .Where(p => p.Handle != Game.Player.Character.Handle && !p.IsDead && p.RelationshipGroup != Main.RelationshipGroup)
+ .OrderBy(p => (p.Position - Game.Player.Character.Position).Length())
+ .Take(10)) // only 10 for now
+ {
+ Main.MainNetworking.SendNpcData(ped);
+ }
+ }
+ }
+ }
+}
diff --git a/Client/Main.cs b/Client/Main.cs
new file mode 100644
index 0000000..9d0b925
--- /dev/null
+++ b/Client/Main.cs
@@ -0,0 +1,362 @@
+using System;
+using System.Linq;
+using System.Windows.Forms;
+using System.Collections.Generic;
+
+using CoopClient.Entities;
+
+using GTA;
+using GTA.Native;
+
+using LemonUI;
+using LemonUI.Menus;
+
+namespace CoopClient
+{
+ public class Main : Script
+ {
+ public static RelationshipGroup RelationshipGroup;
+
+ private bool GameLoaded = false;
+
+ public static readonly string CurrentModVersion = Enum.GetValues(typeof(ModVersion)).Cast().Last().ToString();
+
+ public static bool ShareNpcsWithPlayers = false;
+ public static bool NpcsAllowed = false;
+
+ public static Settings MainSettings = Util.ReadSettings();
+ public static ObjectPool MainMenuPool = new ObjectPool();
+ public static NativeMenu MainMenu = new NativeMenu("GTACoop:R", CurrentModVersion.Replace("_", "."))
+ {
+ UseMouse = false,
+ Alignment = MainSettings.FlipMenu ? GTA.UI.Alignment.Right : GTA.UI.Alignment.Left
+ };
+ public static NativeMenu MainSettingsMenu = new NativeMenu("GTACoop:R", "Settings", "Go to the settings")
+ {
+ UseMouse = false,
+ Alignment = MainSettings.FlipMenu ? GTA.UI.Alignment.Right : GTA.UI.Alignment.Left
+ };
+ public static Chat MainChat = new Chat();
+ public static PlayerList MainPlayerList = new PlayerList();
+
+ public static Networking MainNetworking = new Networking();
+
+ public static string LocalPlayerID = null;
+ public static readonly Dictionary Players = new Dictionary();
+ public static readonly Dictionary Npcs = new Dictionary();
+
+ public Main()
+ {
+ Function.Call((Hash)0x0888C3502DBBEEF5); // _LOAD_MP_DLC_MAPS
+ Function.Call((Hash)0x9BAE5AD2508DF078, true); // _ENABLE_MP_DLC_MAPS
+
+ NativeItem usernameItem = new NativeItem("Username")
+ {
+ AltTitle = MainSettings.Username
+ };
+ usernameItem.Activated += (menu, item) =>
+ {
+ string newUsername = Game.GetUserInput(WindowTitle.EnterMessage20, usernameItem.AltTitle, 20);
+ if (!string.IsNullOrWhiteSpace(newUsername))
+ {
+ MainSettings.Username = newUsername;
+ Util.SaveSettings();
+
+ usernameItem.AltTitle = newUsername;
+ MainMenuPool.RefreshAll();
+ }
+ };
+
+ NativeItem serverIpItem = new NativeItem("Server IP")
+ {
+ AltTitle = MainSettings.LastServerAddress
+ };
+ serverIpItem.Activated += (menu, item) =>
+ {
+ string newServerIp = Game.GetUserInput(WindowTitle.EnterMessage60, serverIpItem.AltTitle, 60);
+ if (!string.IsNullOrWhiteSpace(newServerIp) && newServerIp.Contains(":"))
+ {
+ MainSettings.LastServerAddress = newServerIp;
+ Util.SaveSettings();
+
+ serverIpItem.AltTitle = newServerIp;
+ MainMenuPool.RefreshAll();
+ }
+
+ };
+
+ NativeItem serverConnectItem = new NativeItem("Connect");
+ serverConnectItem.Activated += (sender, item) =>
+ {
+ MainNetworking.DisConnectFromServer(MainSettings.LastServerAddress);
+ };
+
+ NativeCheckboxItem shareNpcsItem = new NativeCheckboxItem("Share Npcs", ShareNpcsWithPlayers);
+ shareNpcsItem.CheckboxChanged += (item, check) =>
+ {
+ ShareNpcsWithPlayers = shareNpcsItem.Checked;
+ };
+ shareNpcsItem.Enabled = false;
+
+ NativeCheckboxItem flipMenuItem = new NativeCheckboxItem("Flip menu", MainSettings.FlipMenu);
+ flipMenuItem.CheckboxChanged += (item, check) =>
+ {
+ MainMenu.Alignment = flipMenuItem.Checked ? GTA.UI.Alignment.Right : GTA.UI.Alignment.Left;
+ MainSettingsMenu.Alignment = flipMenuItem.Checked ? GTA.UI.Alignment.Right : GTA.UI.Alignment.Left;
+
+ MainSettings.FlipMenu = flipMenuItem.Checked;
+ Util.SaveSettings();
+ };
+
+ NativeItem aboutItem = new NativeItem("About", "~g~GTACoop~s~:~b~R ~s~by ~o~EntenKoeniq")
+ {
+ LeftBadge = new LemonUI.Elements.ScaledTexture("commonmenu", "shop_new_star")
+ };
+
+#if DEBUG
+ NativeCheckboxItem useDebugItem = new NativeCheckboxItem("Debug", UseDebug);
+ useDebugItem.CheckboxChanged += (item, check) =>
+ {
+ UseDebug = useDebugItem.Checked;
+
+ if (!useDebugItem.Checked && DebugSyncPed != null)
+ {
+ if (DebugSyncPed.Character.Exists())
+ {
+ DebugSyncPed.Character.Kill();
+ DebugSyncPed.Character.Delete();
+ }
+
+ DebugSyncPed = null;
+ FullDebugSync = true;
+ Players.Remove("DebugKey");
+ }
+ };
+#endif
+
+ MainMenu.Add(usernameItem);
+ MainMenu.Add(serverIpItem);
+ MainMenu.Add(serverConnectItem);
+ MainMenu.AddSubMenu(MainSettingsMenu);
+ MainSettingsMenu.Add(shareNpcsItem);
+ MainSettingsMenu.Add(flipMenuItem);
+#if DEBUG
+ MainSettingsMenu.Add(useDebugItem);
+#endif
+ MainMenu.Add(aboutItem);
+
+ MainMenuPool.Add(MainMenu);
+ MainMenuPool.Add(MainSettingsMenu);
+
+ Tick += OnTick;
+ KeyDown += OnKeyDown;
+ }
+
+ private int LastDataSend;
+ private void OnTick(object sender, EventArgs e)
+ {
+ if (Game.IsLoading)
+ {
+ return;
+ }
+ else if (!GameLoaded && (GameLoaded = true))
+ {
+ RelationshipGroup = World.AddRelationshipGroup("SYNCPED");
+ Game.Player.Character.RelationshipGroup = RelationshipGroup;
+
+ Function.Call(Hash.SET_CAN_ATTACK_FRIENDLY, Game.Player.Character, true, true);
+ Function.Call(Hash.SET_PED_CAN_BE_TARGETTED, true);
+ }
+
+ MainMenuPool.Process();
+
+ MainNetworking.ReceiveMessages();
+
+ if (!MainNetworking.IsOnServer())
+ {
+ return;
+ }
+
+ if (Game.Player.Character.IsGettingIntoVehicle)
+ {
+ GTA.UI.Notification.Show("~y~Vehicles are not sync yet!", true);
+ }
+
+ MainChat.Tick();
+ if (!MainChat.Focused && !MainMenuPool.AreAnyVisible)
+ {
+ MainPlayerList.Tick();
+ }
+
+ // Display all players
+ foreach (KeyValuePair player in Players)
+ {
+ player.Value.DisplayLocally(player.Value.Username);
+ }
+
+ if (UseDebug)
+ {
+ Debug();
+ }
+
+ if ((Environment.TickCount - LastDataSend) >= (1000 / 60))
+ {
+ MainNetworking.SendPlayerData();
+
+ LastDataSend = Environment.TickCount;
+ }
+ }
+
+ private void OnKeyDown(object sender, KeyEventArgs e)
+ {
+ if (MainChat.Focused)
+ {
+ MainChat.OnKeyDown(e.KeyCode);
+ return;
+ }
+
+ switch (e.KeyCode)
+ {
+ case Keys.F9:
+ if (MainMenuPool.AreAnyVisible)
+ {
+ MainMenu.Visible = false;
+ MainSettingsMenu.Visible = false;
+ }
+ else
+ {
+ MainMenu.Visible = true;
+ }
+ break;
+ case Keys.T:
+ if (MainNetworking.IsOnServer())
+ {
+ MainChat.Focused = true;
+ }
+ break;
+ case Keys.Y:
+ if (MainNetworking.IsOnServer())
+ {
+ int time = Environment.TickCount;
+
+ MainPlayerList.Pressed = (time - MainPlayerList.Pressed) < 5000 ? (time - 6000) : time;
+ }
+ break;
+ }
+ }
+
+ private DateTime ArtificialLagCounter = DateTime.MinValue;
+ private EntitiesPlayer DebugSyncPed;
+ private bool FullDebugSync = true;
+ private bool UseDebug = false;
+
+ private void Debug()
+ {
+ var player = Game.Player.Character;
+ if (!Players.ContainsKey("DebugKey"))
+ {
+ Players.Add("DebugKey", new EntitiesPlayer() { SocialClubName = "DEBUG", Username = "DebugPlayer" });
+ DebugSyncPed = Players["DebugKey"];
+ }
+
+ if (!player.IsInVehicle() && DateTime.Now.Subtract(ArtificialLagCounter).TotalMilliseconds >= 300)
+ {
+ ArtificialLagCounter = DateTime.Now;
+
+ #region SPEED
+ byte speed = 0;
+ if (Game.Player.Character.IsWalking)
+ {
+ speed = 1;
+ }
+ else if (Game.Player.Character.IsRunning)
+ {
+ speed = 2;
+ }
+ else if (Game.Player.Character.IsSprinting || Game.IsControlPressed(GTA.Control.Sprint))
+ {
+ speed = 3;
+ }
+ #endregion
+
+ #region SHOOTING - AIMING
+ bool aiming = player.IsAiming;
+ bool shooting = player.IsShooting && player.Weapons.Current?.AmmoInClip != 0;
+
+ GTA.Math.Vector3 aimCoord = new GTA.Math.Vector3();
+ if (aiming || shooting)
+ {
+ aimCoord = Util.RaycastEverything(new GTA.Math.Vector2(0, 0));
+ }
+ #endregion
+
+ #region FLAG
+ byte? flags = 0;
+
+ if (FullDebugSync)
+ {
+ flags |= (byte)PedDataFlags.LastSyncWasFull;
+ }
+
+ if (aiming)
+ {
+ flags |= (byte)PedDataFlags.IsAiming;
+ }
+
+ if (shooting)
+ {
+ flags |= (byte)PedDataFlags.IsShooting;
+ }
+
+ if (player.IsReloading)
+ {
+ flags |= (byte)PedDataFlags.IsReloading;
+ }
+
+ if (player.IsJumping)
+ {
+ flags |= (byte)PedDataFlags.IsJumping;
+ }
+
+ if (player.IsRagdoll)
+ {
+ flags |= (byte)PedDataFlags.IsRagdoll;
+ }
+
+ if (player.IsOnFire)
+ {
+ flags |= (byte)PedDataFlags.IsOnFire;
+ }
+ #endregion
+
+ if (FullDebugSync)
+ {
+ DebugSyncPed.ModelHash = player.Model.Hash;
+ DebugSyncPed.Props = Util.GetPedProps(player);
+ }
+ DebugSyncPed.Health = player.Health;
+ DebugSyncPed.Position = player.Position;
+ DebugSyncPed.Rotation = player.Rotation;
+ DebugSyncPed.Velocity = player.Velocity;
+ DebugSyncPed.Speed = speed;
+ DebugSyncPed.AimCoords = aimCoord;
+ DebugSyncPed.CurrentWeaponHash = (int)player.Weapons.Current.Hash;
+ DebugSyncPed.LastSyncWasFull = (flags.Value & (byte)PedDataFlags.LastSyncWasFull) > 0;
+ DebugSyncPed.IsAiming = (flags.Value & (byte)PedDataFlags.IsAiming) > 0;
+ DebugSyncPed.IsShooting = (flags.Value & (byte)PedDataFlags.IsShooting) > 0;
+ DebugSyncPed.IsReloading = (flags.Value & (byte)PedDataFlags.IsReloading) > 0;
+ DebugSyncPed.IsJumping = (flags.Value & (byte)PedDataFlags.IsJumping) > 0;
+ DebugSyncPed.IsRagdoll = (flags.Value & (byte)PedDataFlags.IsRagdoll) > 0;
+ DebugSyncPed.IsOnFire = (flags.Value & (byte)PedDataFlags.IsOnFire) > 0;
+ }
+
+ if (DebugSyncPed.Character != null && DebugSyncPed.Character.Exists())
+ {
+ Function.Call(Hash.SET_ENTITY_NO_COLLISION_ENTITY, DebugSyncPed.Character.Handle, player.Handle, false);
+ Function.Call(Hash.SET_ENTITY_NO_COLLISION_ENTITY, player.Handle, DebugSyncPed.Character.Handle, false);
+ }
+
+ FullDebugSync = !FullDebugSync;
+ }
+ }
+}
diff --git a/Client/Networking.cs b/Client/Networking.cs
new file mode 100644
index 0000000..976fb52
--- /dev/null
+++ b/Client/Networking.cs
@@ -0,0 +1,556 @@
+using System;
+
+using CoopClient.Entities;
+
+using Lidgren.Network;
+
+using GTA;
+using GTA.Math;
+using GTA.Native;
+
+namespace CoopClient
+{
+ public class Networking
+ {
+ public NetClient Client;
+
+ public void DisConnectFromServer(string address)
+ {
+ if (IsOnServer())
+ {
+ NetOutgoingMessage outgoingMessage = Client.CreateMessage();
+ new PlayerDisconnectPacket() { Player = Main.LocalPlayerID }.PacketToNetOutGoingMessage(outgoingMessage);
+ Client.SendMessage(outgoingMessage, NetDeliveryMethod.ReliableOrdered);
+ Client.FlushSendQueue();
+
+ Client.Disconnect("Disconnected");
+ }
+ else
+ {
+ // 6d4ec318f1c43bd62fe13d5a7ab28650 = GTACOOP:R
+ NetPeerConfiguration config = new NetPeerConfiguration("6d4ec318f1c43bd62fe13d5a7ab28650")
+ {
+ AutoFlushSendQueue = false
+ };
+
+ Client = new NetClient(config);
+
+ Client.Start();
+
+ string[] ip = address.Split(':');
+
+ // Send HandshakePacket
+ NetOutgoingMessage outgoingMessage = Client.CreateMessage();
+ new HandshakePacket()
+ {
+ ID = string.Empty,
+ SocialClubName = Game.Player.Name,
+ Username = Main.MainSettings.Username,
+ ModVersion = Main.CurrentModVersion,
+ NpcsAllowed = false
+ }.PacketToNetOutGoingMessage(outgoingMessage);
+
+ Client.Connect(ip[0], short.Parse(ip[1]), outgoingMessage);
+ }
+ }
+
+ public bool IsOnServer()
+ {
+ return Client?.ConnectionStatus == NetConnectionStatus.Connected;
+ }
+
+ public void ReceiveMessages()
+ {
+ if (Client == null)
+ {
+ return;
+ }
+
+ NetIncomingMessage message;
+
+ while ((message = Client.ReadMessage()) != null)
+ {
+ switch (message.MessageType)
+ {
+ case NetIncomingMessageType.StatusChanged:
+ NetConnectionStatus status = (NetConnectionStatus)message.ReadByte();
+
+ string reason = message.ReadString();
+
+ switch (status)
+ {
+ case NetConnectionStatus.InitiatedConnect:
+ Main.MainMenu.Items[0].Enabled = false;
+ Main.MainMenu.Items[1].Enabled = false;
+ Main.MainMenu.Items[2].Enabled = false;
+ GTA.UI.Notification.Show("~y~Trying to connect...");
+ break;
+ case NetConnectionStatus.Connected:
+ if (message.SenderConnection.RemoteHailMessage.ReadByte() != (byte)PacketTypes.HandshakePacket)
+ {
+ Client.Disconnect("Wrong packet!");
+ }
+ else
+ {
+ Packet remoteHailMessagePacket;
+ remoteHailMessagePacket = new HandshakePacket();
+ remoteHailMessagePacket.NetIncomingMessageToPacket(message.SenderConnection.RemoteHailMessage);
+
+ HandshakePacket handshakePacket = (HandshakePacket)remoteHailMessagePacket;
+ Main.LocalPlayerID = handshakePacket.ID;
+ Main.NpcsAllowed = handshakePacket.NpcsAllowed;
+
+ foreach (Ped entity in World.GetAllPeds())
+ {
+ if (entity.Handle != Game.Player.Character.Handle)
+ {
+ entity.Kill();
+ entity.Delete();
+ }
+ }
+
+ foreach (Vehicle vehicle in World.GetAllVehicles())
+ {
+ if (Game.Player.Character.CurrentVehicle?.Handle != vehicle.Handle)
+ {
+ vehicle.Delete();
+ }
+ }
+
+ Function.Call(Hash.SET_GARBAGE_TRUCKS, 0);
+ Function.Call(Hash.SET_RANDOM_BOATS, 0);
+ Function.Call(Hash.SET_RANDOM_TRAINS, 0);
+
+ Main.MainMenu.Items[2].Enabled = true;
+ Main.MainMenu.Items[2].Title = "Disconnect";
+ Main.MainSettingsMenu.Items[0].Enabled = Main.NpcsAllowed;
+
+ Main.MainChat.Init();
+ Main.MainPlayerList.Init(Main.MainSettings.Username);
+
+ // Send player connect packet
+ NetOutgoingMessage outgoingMessage = Client.CreateMessage();
+ new PlayerConnectPacket()
+ {
+ Player = Main.LocalPlayerID,
+ SocialClubName = string.Empty,
+ Username = string.Empty
+ }.PacketToNetOutGoingMessage(outgoingMessage);
+ Client.SendMessage(outgoingMessage, NetDeliveryMethod.ReliableOrdered);
+ Client.FlushSendQueue();
+
+ GTA.UI.Notification.Show("~g~Connected!");
+ }
+ break;
+ case NetConnectionStatus.Disconnected:
+ GTA.UI.Notification.Show("~r~" + reason);
+
+ // Reset all values
+ FullPlayerSync = true;
+
+ Main.NpcsAllowed = false;
+
+ if (Main.MainChat.Focused)
+ {
+ Main.MainChat.Focused = false;
+ }
+
+ Main.MainChat.Clear();
+
+ Main.MainMenu.Items[0].Enabled = true;
+ Main.MainMenu.Items[1].Enabled = true;
+ Main.MainMenu.Items[2].Enabled = true;
+ Main.MainMenu.Items[2].Title = "Connect";
+ Main.MainSettingsMenu.Items[0].Enabled = false;
+
+ Main.Players.Clear();
+ Main.Npcs.Clear();
+
+ Vector3 pos = Game.Player.Character.Position;
+ Function.Call(Hash.CLEAR_AREA_OF_PEDS, pos.X, pos.Y, pos.Z, 300.0f, 0);
+ Function.Call(Hash.CLEAR_AREA_OF_VEHICLES, pos.X, pos.Y, pos.Z, 300.0f, 0);
+ break;
+ }
+ break;
+ case NetIncomingMessageType.Data:
+ byte packetType = message.ReadByte();
+
+ Packet packet;
+
+ switch (packetType)
+ {
+ case (byte)PacketTypes.PlayerConnectPacket:
+ packet = new PlayerConnectPacket();
+ packet.NetIncomingMessageToPacket(message);
+ PlayerConnect((PlayerConnectPacket)packet);
+ break;
+ case (byte)PacketTypes.PlayerDisconnectPacket:
+ packet = new PlayerDisconnectPacket();
+ packet.NetIncomingMessageToPacket(message);
+ PlayerDisconnect((PlayerDisconnectPacket)packet);
+ break;
+ case (byte)PacketTypes.FullSyncPlayerPacket:
+ packet = new FullSyncPlayerPacket();
+ packet.NetIncomingMessageToPacket(message);
+ FullSyncPlayer((FullSyncPlayerPacket)packet);
+ break;
+ case (byte)PacketTypes.FullSyncNpcPacket:
+ packet = new FullSyncNpcPacket();
+ packet.NetIncomingMessageToPacket(message);
+ FullSyncNpc((FullSyncNpcPacket)packet);
+ break;
+ case (byte)PacketTypes.LightSyncPlayerPacket:
+ packet = new LightSyncPlayerPacket();
+ packet.NetIncomingMessageToPacket(message);
+ LightSyncPlayer((LightSyncPlayerPacket)packet);
+ break;
+ case (byte)PacketTypes.ChatMessagePacket:
+ packet = new ChatMessagePacket();
+ packet.NetIncomingMessageToPacket(message);
+
+ ChatMessagePacket chatMessagePacket = (ChatMessagePacket)packet;
+ Main.MainChat.AddMessage(chatMessagePacket.Username, chatMessagePacket.Message);
+ break;
+ }
+ break;
+ case NetIncomingMessageType.DebugMessage:
+ case NetIncomingMessageType.ErrorMessage:
+ case NetIncomingMessageType.WarningMessage:
+ case NetIncomingMessageType.VerboseDebugMessage:
+ break;
+ default:
+ break;
+ }
+
+ Client.Recycle(message);
+ }
+ }
+
+ #region GET
+ private void PlayerConnect(PlayerConnectPacket packet)
+ {
+ EntitiesPlayer player = new EntitiesPlayer()
+ {
+ SocialClubName = packet.SocialClubName,
+ Username = packet.Username
+ };
+
+ Main.Players.Add(packet.Player, player);
+
+ Main.MainPlayerList.Update(Main.Players, Main.MainSettings.Username);
+ }
+
+ private void PlayerDisconnect(PlayerDisconnectPacket packet)
+ {
+ if (Main.Players.ContainsKey(packet.Player))
+ {
+ Main.Players.Remove(packet.Player);
+
+ Main.MainPlayerList.Update(Main.Players, Main.MainSettings.Username);
+ }
+ }
+
+ private void FullSyncPlayer(FullSyncPlayerPacket packet)
+ {
+ if (Main.Players.ContainsKey(packet.Player))
+ {
+ EntitiesPlayer player = Main.Players[packet.Player];
+ player.ModelHash = packet.ModelHash;
+ player.Props = packet.Props;
+ player.Health = packet.Health;
+ player.Position = packet.Position.ToVector();
+ player.Rotation = packet.Rotation.ToVector();
+ player.Velocity = packet.Velocity.ToVector();
+ player.Speed = packet.Speed;
+ player.AimCoords = packet.AimCoords.ToVector();
+ player.LastSyncWasFull = (packet.Flag.Value & (byte)PedDataFlags.LastSyncWasFull) > 0;
+ player.IsAiming = (packet.Flag.Value & (byte)PedDataFlags.IsAiming) > 0;
+ player.IsShooting = (packet.Flag.Value & (byte)PedDataFlags.IsShooting) > 0;
+ player.IsReloading = (packet.Flag.Value & (byte)PedDataFlags.IsReloading) > 0;
+ player.IsJumping = (packet.Flag.Value & (byte)PedDataFlags.IsJumping) > 0;
+ player.IsRagdoll = (packet.Flag.Value & (byte)PedDataFlags.IsRagdoll) > 0;
+ player.IsOnFire = (packet.Flag.Value & (byte)PedDataFlags.IsOnFire) > 0;
+ }
+ }
+
+ private void FullSyncNpc(FullSyncNpcPacket packet)
+ {
+ if (Main.Npcs.ContainsKey(packet.ID))
+ {
+ EntitiesNpc npc = Main.Npcs[packet.ID];
+ npc.LastUpdateReceived = Environment.TickCount;
+ npc.ModelHash = packet.ModelHash;
+ npc.Props = packet.Props;
+ npc.Health = packet.Health;
+ npc.Position = packet.Position.ToVector();
+ npc.Rotation = packet.Rotation.ToVector();
+ npc.Velocity = packet.Velocity.ToVector();
+ npc.Speed = packet.Speed;
+ npc.AimCoords = packet.AimCoords.ToVector();
+ npc.LastSyncWasFull = (packet.Flag.Value & (byte)PedDataFlags.LastSyncWasFull) > 0;
+ npc.IsAiming = (packet.Flag.Value & (byte)PedDataFlags.IsAiming) > 0;
+ npc.IsShooting = (packet.Flag.Value & (byte)PedDataFlags.IsShooting) > 0;
+ npc.IsReloading = (packet.Flag.Value & (byte)PedDataFlags.IsReloading) > 0;
+ npc.IsJumping = (packet.Flag.Value & (byte)PedDataFlags.IsJumping) > 0;
+ npc.IsRagdoll = (packet.Flag.Value & (byte)PedDataFlags.IsRagdoll) > 0;
+ npc.IsOnFire = (packet.Flag.Value & (byte)PedDataFlags.IsOnFire) > 0;
+ }
+ else
+ {
+ Main.Npcs.Add(packet.ID, new EntitiesNpc()
+ {
+ LastUpdateReceived = Environment.TickCount,
+ ModelHash = packet.ModelHash,
+ Props = packet.Props,
+ Health = packet.Health,
+ Position = packet.Position.ToVector(),
+ Rotation = packet.Rotation.ToVector(),
+ Velocity = packet.Velocity.ToVector(),
+ Speed = packet.Speed,
+ AimCoords = packet.AimCoords.ToVector(),
+ LastSyncWasFull = (packet.Flag.Value & (byte)PedDataFlags.LastSyncWasFull) > 0,
+ IsAiming = (packet.Flag.Value & (byte)PedDataFlags.IsAiming) > 0,
+ IsShooting = (packet.Flag.Value & (byte)PedDataFlags.IsShooting) > 0,
+ IsReloading = (packet.Flag.Value & (byte)PedDataFlags.IsReloading) > 0,
+ IsJumping = (packet.Flag.Value & (byte)PedDataFlags.IsJumping) > 0,
+ IsRagdoll = (packet.Flag.Value & (byte)PedDataFlags.IsRagdoll) > 0,
+ IsOnFire = (packet.Flag.Value & (byte)PedDataFlags.IsOnFire) > 0
+ });
+ }
+ }
+
+ private void LightSyncPlayer(LightSyncPlayerPacket packet)
+ {
+ if (Main.Players.ContainsKey(packet.Player))
+ {
+ EntitiesPlayer player = Main.Players[packet.Player];
+ player.Health = packet.Health;
+ player.Position = packet.Position.ToVector();
+ player.Rotation = packet.Rotation.ToVector();
+ player.Velocity = packet.Velocity.ToVector();
+ player.Speed = packet.Speed;
+ player.LastSyncWasFull = (packet.Flag.Value & (byte)PedDataFlags.LastSyncWasFull) > 0;
+ player.IsAiming = (packet.Flag.Value & (byte)PedDataFlags.IsAiming) > 0;
+ player.IsShooting = (packet.Flag.Value & (byte)PedDataFlags.IsShooting) > 0;
+ player.IsReloading = (packet.Flag.Value & (byte)PedDataFlags.IsReloading) > 0;
+ player.IsJumping = (packet.Flag.Value & (byte)PedDataFlags.IsJumping) > 0;
+ player.IsRagdoll = (packet.Flag.Value & (byte)PedDataFlags.IsRagdoll) > 0;
+ player.IsOnFire = (packet.Flag.Value & (byte)PedDataFlags.IsOnFire) > 0;
+ }
+ }
+ #endregion
+
+ #region SEND
+ private bool FullPlayerSync = true;
+ public void SendPlayerData()
+ {
+ Ped player = Game.Player.Character;
+
+ #region SPEED
+ byte speed = 0;
+ if (Game.Player.Character.IsWalking)
+ {
+ speed = 1;
+ }
+ else if (Game.Player.Character.IsRunning)
+ {
+ speed = 2;
+ }
+ else if (Game.Player.Character.IsSprinting)
+ {
+ speed = 3;
+ }
+ #endregion
+
+ #region SHOOTING - AIMING
+ bool aiming = player.IsAiming;
+ bool shooting = player.IsShooting && player.Weapons.Current?.AmmoInClip != 0;
+
+ Vector3 aimCoord = new Vector3();
+ if (aiming || shooting)
+ {
+ aimCoord = Util.RaycastEverything(new Vector2(0, 0));
+ }
+ #endregion
+
+ #region Flags
+ byte? flags = 0;
+
+ if (FullPlayerSync)
+ {
+ flags |= (byte)PedDataFlags.LastSyncWasFull;
+ }
+
+ if (aiming)
+ {
+ flags |= (byte)PedDataFlags.IsAiming;
+ }
+
+ if (shooting)
+ {
+ flags |= (byte)PedDataFlags.IsShooting;
+ }
+
+ if (player.IsReloading)
+ {
+ flags |= (byte)PedDataFlags.IsReloading;
+ }
+
+ if (player.IsJumping)
+ {
+ flags |= (byte)PedDataFlags.IsJumping;
+ }
+
+ if (player.IsRagdoll)
+ {
+ flags |= (byte)PedDataFlags.IsRagdoll;
+ }
+
+ if (player.IsOnFire)
+ {
+ flags |= (byte)PedDataFlags.IsOnFire;
+ }
+ #endregion
+
+ NetOutgoingMessage outgoingMessage = Client.CreateMessage();
+
+ if (FullPlayerSync)
+ {
+ new FullSyncPlayerPacket()
+ {
+ Player = Main.LocalPlayerID,
+ ModelHash = player.Model.Hash,
+ Props = Util.GetPedProps(player),
+ Health = player.Health,
+ Position = player.Position.ToLVector(),
+ Rotation = player.Rotation.ToLVector(),
+ Velocity = player.Velocity.ToLVector(),
+ Speed = speed,
+ AimCoords = aimCoord.ToLVector(),
+ CurrentWeaponHash = (int)player.Weapons.Current.Hash,
+ Flag = flags
+ }.PacketToNetOutGoingMessage(outgoingMessage);
+ }
+ else
+ {
+ new LightSyncPlayerPacket()
+ {
+ Player = Main.LocalPlayerID,
+ Health = player.Health,
+ Position = player.Position.ToLVector(),
+ Rotation = player.Rotation.ToLVector(),
+ Velocity = player.Velocity.ToLVector(),
+ Speed = speed,
+ AimCoords = aimCoord.ToLVector(),
+ CurrentWeaponHash = (int)player.Weapons.Current.Hash,
+ Flag = flags
+ }.PacketToNetOutGoingMessage(outgoingMessage);
+ }
+
+ Client.SendMessage(outgoingMessage, NetDeliveryMethod.ReliableOrdered);
+ Client.FlushSendQueue();
+
+ FullPlayerSync = !FullPlayerSync;
+ }
+
+ public void SendNpcData(Ped npc)
+ {
+ #region SPEED
+ byte speed = 0;
+ if (npc.IsWalking)
+ {
+ speed = 1;
+ }
+ else if (npc.IsRunning)
+ {
+ speed = 2;
+ }
+ else if (npc.IsSprinting)
+ {
+ speed = 3;
+ }
+ #endregion
+
+ #region SHOOTING - AIMING
+ bool aiming = npc.IsAiming;
+ bool shooting = npc.IsShooting && npc.Weapons.Current?.AmmoInClip != 0;
+
+ Vector3 aimCoord = new Vector3();
+ if (aiming || shooting)
+ {
+ aimCoord = Util.GetLastWeaponImpact(npc);
+ }
+ #endregion
+
+ #region Flags
+ byte? flags = 0;
+
+ // FullSync = true
+ flags |= (byte)PedDataFlags.LastSyncWasFull;
+
+ if (shooting)
+ {
+ flags |= (byte)PedDataFlags.IsShooting;
+ }
+
+ if (aiming)
+ {
+ flags |= (byte)PedDataFlags.IsAiming;
+ }
+
+ if (npc.IsReloading)
+ {
+ flags |= (byte)PedDataFlags.IsReloading;
+ }
+
+ if (npc.IsJumping)
+ {
+ flags |= (byte)PedDataFlags.IsJumping;
+ }
+
+ if (npc.IsRagdoll)
+ {
+ flags |= (byte)PedDataFlags.IsRagdoll;
+ }
+
+ if (npc.IsOnFire)
+ {
+ flags |= (byte)PedDataFlags.IsOnFire;
+ }
+ #endregion
+
+ NetOutgoingMessage outgoingMessage = Client.CreateMessage();
+
+ new FullSyncNpcPacket()
+ {
+ ID = Main.LocalPlayerID + npc.Handle,
+ ModelHash = npc.Model.Hash,
+ Props = Util.GetPedProps(npc),
+ Health = npc.Health,
+ Position = npc.Position.ToLVector(),
+ Rotation = npc.Rotation.ToLVector(),
+ Velocity = npc.Velocity.ToLVector(),
+ Speed = speed,
+ AimCoords = aimCoord.ToLVector(),
+ CurrentWeaponHash = (int)npc.Weapons.Current.Hash,
+ Flag = flags
+ }.PacketToNetOutGoingMessage(outgoingMessage);
+
+ Client.SendMessage(outgoingMessage, NetDeliveryMethod.ReliableOrdered);
+ Client.FlushSendQueue();
+ }
+
+ public void SendChatMessage(string message)
+ {
+ NetOutgoingMessage outgoingMessage = Client.CreateMessage();
+ new ChatMessagePacket()
+ {
+ Username = Main.MainSettings.Username,
+ Message = message
+ }.PacketToNetOutGoingMessage(outgoingMessage);
+ Client.SendMessage(outgoingMessage, NetDeliveryMethod.ReliableOrdered);
+ Client.FlushSendQueue();
+ }
+ #endregion
+ }
+}
diff --git a/Client/Packets.cs b/Client/Packets.cs
new file mode 100644
index 0000000..565fe51
--- /dev/null
+++ b/Client/Packets.cs
@@ -0,0 +1,478 @@
+using System;
+using System.IO;
+using System.Collections.Generic;
+
+using Lidgren.Network;
+using ProtoBuf;
+
+using GTA.Math;
+
+namespace CoopClient
+{
+ #region CLIENT-ONLY
+ public static class VectorExtensions
+ {
+ public static LVector3 ToLVector(this Vector3 vec)
+ {
+ return new LVector3()
+ {
+ X = vec.X,
+ Y = vec.Y,
+ Z = vec.Z,
+ };
+ }
+ }
+ #endregion
+
+ [ProtoContract]
+ public struct LVector3
+ {
+ #region CLIENT-ONLY
+ public Vector3 ToVector()
+ {
+ return new Vector3(X, Y, Z);
+ }
+ #endregion
+
+ public LVector3(float X, float Y, float Z)
+ {
+ this.X = X;
+ this.Y = Y;
+ this.Z = Z;
+ }
+
+ [ProtoMember(1)]
+ public float X { get; set; }
+
+ [ProtoMember(2)]
+ public float Y { get; set; }
+
+ [ProtoMember(3)]
+ public float Z { get; set; }
+ }
+
+ public enum ModVersion
+ {
+ V0_1_0
+ }
+
+ public enum PacketTypes
+ {
+ HandshakePacket,
+ PlayerConnectPacket,
+ PlayerDisconnectPacket,
+ FullSyncPlayerPacket,
+ FullSyncNpcPacket,
+ LightSyncPlayerPacket,
+ ChatMessagePacket
+ }
+
+ [Flags]
+ public enum PedDataFlags
+ {
+ LastSyncWasFull = 1 << 0,
+ IsAiming = 1 << 1,
+ IsShooting = 1 << 2,
+ IsReloading = 1 << 3,
+ IsJumping = 1 << 4,
+ IsRagdoll = 1 << 5,
+ IsOnFire = 1 << 6
+ }
+
+ public interface IPacket
+ {
+ void PacketToNetOutGoingMessage(NetOutgoingMessage message);
+ void NetIncomingMessageToPacket(NetIncomingMessage message);
+ }
+
+ public abstract class Packet : IPacket
+ {
+ public abstract void PacketToNetOutGoingMessage(NetOutgoingMessage message);
+ public abstract void NetIncomingMessageToPacket(NetIncomingMessage message);
+ }
+
+ [ProtoContract]
+ public class HandshakePacket : Packet
+ {
+ [ProtoMember(1)]
+ public string ID { get; set; }
+
+ [ProtoMember(2)]
+ public string SocialClubName { get; set; }
+
+ [ProtoMember(3)]
+ public string Username { get; set; }
+
+ [ProtoMember(4)]
+ public string ModVersion { get; set; }
+
+ [ProtoMember(5)]
+ public bool NpcsAllowed { get; set; }
+
+ public override void PacketToNetOutGoingMessage(NetOutgoingMessage message)
+ {
+ message.Write((byte)PacketTypes.HandshakePacket);
+
+ byte[] result;
+ using (MemoryStream stream = new MemoryStream())
+ {
+ Serializer.Serialize(stream, this);
+ result = stream.ToArray();
+ }
+
+ message.Write(result.Length);
+ message.Write(result);
+ }
+
+ public override void NetIncomingMessageToPacket(NetIncomingMessage message)
+ {
+ int len = message.ReadInt32();
+
+ HandshakePacket data;
+ using (MemoryStream stream = new MemoryStream(message.ReadBytes(len)))
+ {
+ data = Serializer.Deserialize(stream);
+ }
+
+ ID = data.ID;
+ SocialClubName = data.SocialClubName;
+ Username = data.Username;
+ ModVersion = data.ModVersion;
+ NpcsAllowed = data.NpcsAllowed;
+ }
+ }
+
+ [ProtoContract]
+ public class PlayerConnectPacket : Packet
+ {
+ [ProtoMember(1)]
+ public string Player { get; set; }
+
+ [ProtoMember(2)]
+ public string SocialClubName { get; set; }
+
+ [ProtoMember(3)]
+ public string Username { get; set; }
+
+ public override void PacketToNetOutGoingMessage(NetOutgoingMessage message)
+ {
+ message.Write((byte)PacketTypes.PlayerConnectPacket);
+
+ byte[] result;
+ using (MemoryStream stream = new MemoryStream())
+ {
+ Serializer.Serialize(stream, this);
+ result = stream.ToArray();
+ }
+
+ message.Write(result.Length);
+ message.Write(result);
+ }
+
+ public override void NetIncomingMessageToPacket(NetIncomingMessage message)
+ {
+ int len = message.ReadInt32();
+
+ PlayerConnectPacket data;
+ using (MemoryStream stream = new MemoryStream(message.ReadBytes(len)))
+ {
+ data = Serializer.Deserialize(stream);
+ }
+
+ Player = data.Player;
+ SocialClubName = data.SocialClubName;
+ Username = data.Username;
+ }
+ }
+
+ [ProtoContract]
+ public class PlayerDisconnectPacket : Packet
+ {
+ [ProtoMember(1)]
+ public string Player { get; set; }
+
+ public override void PacketToNetOutGoingMessage(NetOutgoingMessage message)
+ {
+ message.Write((byte)PacketTypes.PlayerDisconnectPacket);
+
+ byte[] result;
+ using (MemoryStream stream = new MemoryStream())
+ {
+ Serializer.Serialize(stream, this);
+ result = stream.ToArray();
+ }
+
+ message.Write(result.Length);
+ message.Write(result);
+ }
+
+ public override void NetIncomingMessageToPacket(NetIncomingMessage message)
+ {
+ int len = message.ReadInt32();
+
+ PlayerDisconnectPacket data;
+ using (MemoryStream stream = new MemoryStream(message.ReadBytes(len)))
+ {
+ data = Serializer.Deserialize(stream);
+ }
+
+ Player = data.Player;
+ }
+ }
+
+ [ProtoContract]
+ public class FullSyncPlayerPacket : Packet
+ {
+ [ProtoMember(1)]
+ public string Player { get; set; }
+
+ [ProtoMember(2)]
+ public int ModelHash { get; set; }
+
+ [ProtoMember(3)]
+ public Dictionary Props { get; set; }
+
+ [ProtoMember(4)]
+ public int Health { get; set; }
+
+ [ProtoMember(5)]
+ public LVector3 Position { get; set; }
+
+ [ProtoMember(6)]
+ public LVector3 Rotation { get; set; }
+
+ [ProtoMember(7)]
+ public LVector3 Velocity { get; set; }
+
+ [ProtoMember(8)]
+ public byte Speed { get; set; }
+
+ [ProtoMember(9)]
+ public LVector3 AimCoords { get; set; }
+
+ [ProtoMember(10)]
+ public int CurrentWeaponHash { get; set; }
+
+ [ProtoMember(11)]
+ public byte? Flag { get; set; } = 0;
+
+ public override void PacketToNetOutGoingMessage(NetOutgoingMessage message)
+ {
+ message.Write((byte)PacketTypes.FullSyncPlayerPacket);
+
+ byte[] result;
+ using (MemoryStream stream = new MemoryStream())
+ {
+ Serializer.Serialize(stream, this);
+ result = stream.ToArray();
+ }
+
+ message.Write(result.Length);
+ message.Write(result);
+ }
+
+ public override void NetIncomingMessageToPacket(NetIncomingMessage message)
+ {
+ int len = message.ReadInt32();
+
+ FullSyncPlayerPacket data;
+ using (MemoryStream stream = new MemoryStream(message.ReadBytes(len)))
+ {
+ data = Serializer.Deserialize(stream);
+ }
+
+ Player = data.Player;
+ ModelHash = data.ModelHash;
+ Props = data.Props;
+ Health = data.Health;
+ Position = data.Position;
+ Rotation = data.Rotation;
+ Velocity = data.Velocity;
+ Speed = data.Speed;
+ AimCoords = data.AimCoords;
+ CurrentWeaponHash = data.CurrentWeaponHash;
+ Flag = data.Flag;
+ }
+ }
+
+ [ProtoContract]
+ public class FullSyncNpcPacket : Packet
+ {
+ [ProtoMember(1)]
+ public string ID { get; set; }
+
+ [ProtoMember(2)]
+ public int ModelHash { get; set; }
+
+ [ProtoMember(3)]
+ public Dictionary Props { get; set; }
+
+ [ProtoMember(4)]
+ public int Health { get; set; }
+
+ [ProtoMember(5)]
+ public LVector3 Position { get; set; }
+
+ [ProtoMember(6)]
+ public LVector3 Rotation { get; set; }
+
+ [ProtoMember(7)]
+ public LVector3 Velocity { get; set; }
+
+ [ProtoMember(8)]
+ public byte Speed { get; set; }
+
+ [ProtoMember(9)]
+ public LVector3 AimCoords { get; set; }
+
+ [ProtoMember(10)]
+ public int CurrentWeaponHash { get; set; }
+
+ [ProtoMember(11)]
+ public byte? Flag { get; set; } = 0;
+
+ public override void PacketToNetOutGoingMessage(NetOutgoingMessage message)
+ {
+ message.Write((byte)PacketTypes.FullSyncNpcPacket);
+
+ byte[] result;
+ using (MemoryStream stream = new MemoryStream())
+ {
+ Serializer.Serialize(stream, this);
+ result = stream.ToArray();
+ }
+
+ message.Write(result.Length);
+ message.Write(result);
+ }
+
+ public override void NetIncomingMessageToPacket(NetIncomingMessage message)
+ {
+ int len = message.ReadInt32();
+
+ FullSyncNpcPacket data;
+ using (MemoryStream stream = new MemoryStream(message.ReadBytes(len)))
+ {
+ data = Serializer.Deserialize(stream);
+ }
+
+ ID = data.ID;
+ ModelHash = data.ModelHash;
+ Props = data.Props;
+ Health = data.Health;
+ Position = data.Position;
+ Rotation = data.Rotation;
+ Velocity = data.Velocity;
+ Speed = data.Speed;
+ AimCoords = data.AimCoords;
+ CurrentWeaponHash = data.CurrentWeaponHash;
+ Flag = data.Flag;
+ }
+ }
+
+ [ProtoContract]
+ public class LightSyncPlayerPacket : Packet
+ {
+ [ProtoMember(1)]
+ public string Player { get; set; }
+
+ [ProtoMember(2)]
+ public int Health { get; set; }
+
+ [ProtoMember(3)]
+ public LVector3 Position { get; set; }
+
+ [ProtoMember(4)]
+ public LVector3 Rotation { get; set; }
+
+ [ProtoMember(5)]
+ public LVector3 Velocity { get; set; }
+
+ [ProtoMember(6)]
+ public byte Speed { get; set; }
+
+ [ProtoMember(7)]
+ public LVector3 AimCoords { get; set; }
+
+ [ProtoMember(8)]
+ public int CurrentWeaponHash { get; set; }
+
+ [ProtoMember(9)]
+ public byte? Flag { get; set; } = 0;
+
+ public override void PacketToNetOutGoingMessage(NetOutgoingMessage message)
+ {
+ message.Write((byte)PacketTypes.LightSyncPlayerPacket);
+
+ byte[] result;
+ using (MemoryStream stream = new MemoryStream())
+ {
+ Serializer.Serialize(stream, this);
+ result = stream.ToArray();
+ }
+
+ message.Write(result.Length);
+ message.Write(result);
+ }
+
+ public override void NetIncomingMessageToPacket(NetIncomingMessage message)
+ {
+ int len = message.ReadInt32();
+
+ LightSyncPlayerPacket data;
+ using (MemoryStream stream = new MemoryStream(message.ReadBytes(len)))
+ {
+ data = Serializer.Deserialize(stream);
+ }
+
+ Player = data.Player;
+ Health = data.Health;
+ Position = data.Position;
+ Rotation = data.Rotation;
+ Velocity = data.Velocity;
+ Speed = data.Speed;
+ AimCoords = data.AimCoords;
+ CurrentWeaponHash = data.CurrentWeaponHash;
+ Flag = data.Flag;
+ }
+ }
+
+ [ProtoContract]
+ public class ChatMessagePacket : Packet
+ {
+ [ProtoMember(1)]
+ public string Username { get; set; }
+
+ [ProtoMember(2)]
+ public string Message { get; set; }
+
+ public override void PacketToNetOutGoingMessage(NetOutgoingMessage message)
+ {
+ message.Write((byte)PacketTypes.ChatMessagePacket);
+
+ byte[] result;
+ using (MemoryStream stream = new MemoryStream())
+ {
+ Serializer.Serialize(stream, this);
+ result = stream.ToArray();
+ }
+
+ message.Write(result.Length);
+ message.Write(result);
+ }
+
+ public override void NetIncomingMessageToPacket(NetIncomingMessage message)
+ {
+ int len = message.ReadInt32();
+
+ ChatMessagePacket data;
+ using (MemoryStream stream = new MemoryStream(message.ReadBytes(len)))
+ {
+ data = Serializer.Deserialize(stream);
+ }
+
+ Username = data.Username;
+ Message = data.Message;
+ }
+ }
+}
diff --git a/Client/PlayerList.cs b/Client/PlayerList.cs
new file mode 100644
index 0000000..5412278
--- /dev/null
+++ b/Client/PlayerList.cs
@@ -0,0 +1,47 @@
+using System;
+using System.Collections.Generic;
+
+using CoopClient.Entities;
+
+using GTA;
+using GTA.Native;
+
+namespace CoopClient
+{
+ public class PlayerList
+ {
+ private readonly Scaleform MainScaleform = new Scaleform("mp_mm_card_freemode");
+ public int Pressed { get; set; }
+
+ public void Init(string localUsername)
+ {
+ MainScaleform.CallFunction("SET_DATA_SLOT_EMPTY", 0);
+ MainScaleform.CallFunction("SET_DATA_SLOT", 0, "", localUsername, 116, 0, 0, "", "", 2, "", "", ' ');
+ MainScaleform.CallFunction("SET_TITLE", "Player list", "1 players");
+ MainScaleform.CallFunction("DISPLAY_VIEW");
+ }
+
+ public void Update(Dictionary players, string LocalUsername)
+ {
+ MainScaleform.CallFunction("SET_DATA_SLOT_EMPTY", 0);
+ MainScaleform.CallFunction("SET_DATA_SLOT", 0, "", LocalUsername, 116, 0, 0, "", "", 2, "", "", ' ');
+
+ int i = 1;
+ foreach (KeyValuePair player in players)
+ {
+ MainScaleform.CallFunction("SET_DATA_SLOT", i++, "", player.Value.Username, 116, 0, i - 1, "", "", 2, "", "", ' ');
+ }
+
+ MainScaleform.CallFunction("SET_TITLE", "Player list", (players.Count + 1) + " players");
+ MainScaleform.CallFunction("DISPLAY_VIEW");
+ }
+
+ public void Tick()
+ {
+ if ((Environment.TickCount - Pressed) < 5000)
+ {
+ Function.Call(Hash.DRAW_SCALEFORM_MOVIE, MainScaleform.Handle, 0.122f, 0.3f, 0.28f, 0.6f, 255, 255, 255, 255, 0);
+ }
+ }
+ }
+}
diff --git a/Client/Properties/AssemblyInfo.cs b/Client/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..63552ab
--- /dev/null
+++ b/Client/Properties/AssemblyInfo.cs
@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("Client")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("Client")]
+[assembly: AssemblyCopyright("Copyright © 2021")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components. If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("ef56d109-1f22-43e0-9dff-cfcfb94e0681")]
+
+// Version information for an assembly consists of the following four values:
+//
+// Major Version
+// Minor Version
+// Build Number
+// Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
diff --git a/Client/Settings.cs b/Client/Settings.cs
new file mode 100644
index 0000000..4cbeb72
--- /dev/null
+++ b/Client/Settings.cs
@@ -0,0 +1,9 @@
+namespace CoopClient
+{
+ public class Settings
+ {
+ public string Username { get; set; } = "Player";
+ public string LastServerAddress { get; set; } = "127.0.0.1:4499";
+ public bool FlipMenu { get; set; } = false;
+ }
+}
diff --git a/Client/Util.cs b/Client/Util.cs
new file mode 100644
index 0000000..1464fdf
--- /dev/null
+++ b/Client/Util.cs
@@ -0,0 +1,189 @@
+using System;
+using System.IO;
+using System.Xml.Serialization;
+using System.Collections.Generic;
+
+using GTA;
+using GTA.Native;
+using GTA.Math;
+
+namespace CoopClient
+{
+ class Util
+ {
+ public static Dictionary GetPedProps(Ped ped)
+ {
+ Dictionary result = new Dictionary();
+ for (int i = 0; i < 11; i++)
+ {
+ int mod = Function.Call(Hash.GET_PED_DRAWABLE_VARIATION, ped.Handle, i);
+ result.Add(i, mod);
+ }
+ return result;
+ }
+
+ public static Settings ReadSettings()
+ {
+ XmlSerializer ser = new XmlSerializer(typeof(Settings));
+
+ string path = Directory.GetCurrentDirectory() + "\\scripts\\CoopSettings.xml";
+ Settings settings = null;
+
+ if (File.Exists(path))
+ {
+ using (FileStream stream = File.OpenRead(path))
+ {
+ settings = (Settings)ser.Deserialize(stream);
+ }
+
+ using (FileStream stream = new FileStream(path, File.Exists(path) ? FileMode.Truncate : FileMode.Create, FileAccess.ReadWrite))
+ {
+ ser.Serialize(stream, settings);
+ }
+ }
+ else
+ {
+ using (FileStream stream = File.OpenWrite(path))
+ {
+ ser.Serialize(stream, settings = new Settings());
+ }
+ }
+
+ return settings;
+ }
+
+ public static void SaveSettings()
+ {
+ try
+ {
+ string path = Directory.GetCurrentDirectory() + "\\scripts\\CoopSettings.xml";
+
+ using (FileStream stream = new FileStream(path, File.Exists(path) ? FileMode.Truncate : FileMode.Create, FileAccess.ReadWrite))
+ {
+ XmlSerializer ser = new XmlSerializer(typeof(Settings));
+ ser.Serialize(stream, Main.MainSettings);
+ }
+ }
+ catch (Exception ex)
+ {
+ GTA.UI.Notification.Show("Error saving player settings: " + ex.Message);
+ }
+ }
+
+ public static Vector3 GetLastWeaponImpact(Ped ped)
+ {
+ OutputArgument coord = new OutputArgument();
+ if (!Function.Call(Hash.GET_PED_LAST_WEAPON_IMPACT_COORD, ped.Handle, coord))
+ {
+ return new Vector3();
+ }
+
+ return coord.GetResult();
+ }
+
+ public static double DegToRad(double deg)
+ {
+ return deg * Math.PI / 180.0;
+ }
+
+ public static Vector3 RotationToDirection(Vector3 rotation)
+ {
+ double z = DegToRad(rotation.Z);
+ double x = DegToRad(rotation.X);
+ double num = Math.Abs(Math.Cos(x));
+
+ return new Vector3
+ {
+ X = (float)(-Math.Sin(z) * num),
+ Y = (float)(Math.Cos(z) * num),
+ Z = (float)Math.Sin(x)
+ };
+ }
+
+ public static bool WorldToScreenRel(Vector3 worldCoords, out Vector2 screenCoords)
+ {
+ OutputArgument num1 = new OutputArgument();
+ OutputArgument num2 = new OutputArgument();
+
+ if (!Function.Call(Hash.GET_SCREEN_COORD_FROM_WORLD_COORD, worldCoords.X, worldCoords.Y, worldCoords.Z, num1, num2))
+ {
+ screenCoords = new Vector2();
+ return false;
+ }
+
+ screenCoords = new Vector2((num1.GetResult() - 0.5f) * 2, (num2.GetResult() - 0.5f) * 2);
+ return true;
+ }
+
+ public static Vector3 ScreenRelToWorld(Vector3 camPos, Vector3 camRot, Vector2 coord)
+ {
+ Vector3 camForward = RotationToDirection(camRot);
+ Vector3 rotUp = camRot + new Vector3(10, 0, 0);
+ Vector3 rotDown = camRot + new Vector3(-10, 0, 0);
+ Vector3 rotLeft = camRot + new Vector3(0, 0, -10);
+ Vector3 rotRight = camRot + new Vector3(0, 0, 10);
+
+ Vector3 camRight = RotationToDirection(rotRight) - RotationToDirection(rotLeft);
+ Vector3 camUp = RotationToDirection(rotUp) - RotationToDirection(rotDown);
+
+ double rollRad = -DegToRad(camRot.Y);
+
+ Vector3 camRightRoll = camRight * (float)Math.Cos(rollRad) - camUp * (float)Math.Sin(rollRad);
+ Vector3 camUpRoll = camRight * (float)Math.Sin(rollRad) + camUp * (float)Math.Cos(rollRad);
+
+ Vector3 point3D = camPos + camForward * 10.0f + camRightRoll + camUpRoll;
+ if (!WorldToScreenRel(point3D, out Vector2 point2D))
+ {
+ return camPos + camForward * 10.0f;
+ }
+
+ Vector3 point3DZero = camPos + camForward * 10.0f;
+ if (!WorldToScreenRel(point3DZero, out Vector2 point2DZero))
+ {
+ return camPos + camForward * 10.0f;
+ }
+
+ const double eps = 0.001;
+ if (Math.Abs(point2D.X - point2DZero.X) < eps || Math.Abs(point2D.Y - point2DZero.Y) < eps)
+ {
+ return camPos + camForward * 10.0f;
+ }
+
+ float scaleX = (coord.X - point2DZero.X) / (point2D.X - point2DZero.X);
+ float scaleY = (coord.Y - point2DZero.Y) / (point2D.Y - point2DZero.Y);
+
+ return camPos + camForward * 10.0f + camRightRoll * scaleX + camUpRoll * scaleY;
+ }
+
+ public static Vector3 RaycastEverything(Vector2 screenCoord)
+ {
+ Vector3 camPos = GameplayCamera.Position;
+ Vector3 camRot = GameplayCamera.Rotation;
+ const float raycastToDist = 100.0f;
+ const float raycastFromDist = 1f;
+
+ Vector3 target3D = ScreenRelToWorld(camPos, camRot, screenCoord);
+ Vector3 source3D = camPos;
+
+ Entity ignoreEntity = Game.Player.Character;
+ if (Game.Player.Character.IsInVehicle())
+ {
+ ignoreEntity = Game.Player.Character.CurrentVehicle;
+ }
+
+ Vector3 dir = target3D - source3D;
+ dir.Normalize();
+ RaycastResult raycastResults = World.Raycast(source3D + dir * raycastFromDist,
+ source3D + dir * raycastToDist,
+ (IntersectFlags)(1 | 16 | 256 | 2 | 4 | 8), // | peds + vehicles
+ ignoreEntity);
+
+ if (raycastResults.DidHit)
+ {
+ return raycastResults.HitPosition;
+ }
+
+ return camPos + dir * raycastToDist;
+ }
+ }
+}
diff --git a/Client/WorldThread.cs b/Client/WorldThread.cs
new file mode 100644
index 0000000..91a69c6
--- /dev/null
+++ b/Client/WorldThread.cs
@@ -0,0 +1,26 @@
+using System;
+
+using GTA;
+using GTA.Native;
+
+namespace CoopClient
+{
+ public class WorldThread : Script
+ {
+ public WorldThread()
+ {
+ Tick += OnTick;
+ Interval = 1000 / 60;
+ }
+
+ public static void OnTick(object sender, EventArgs e)
+ {
+ if (Game.IsLoading)
+ {
+ return;
+ }
+
+ Function.Call((Hash)0xB96B00E976BE977F, 0.0f); // _SET_WAVES_INTENSITY
+ }
+ }
+}
diff --git a/Client/packages.config b/Client/packages.config
new file mode 100644
index 0000000..bd81797
--- /dev/null
+++ b/Client/packages.config
@@ -0,0 +1,4 @@
+
+
+
+
\ No newline at end of file
diff --git a/GTACoop.sln b/GTACoop.sln
new file mode 100644
index 0000000..f3c7c1e
--- /dev/null
+++ b/GTACoop.sln
@@ -0,0 +1,31 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.0.31423.177
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "CoopServer", "Server\CoopServer.csproj", "{84AB99D9-5E00-4CA2-B1DD-56B8419AAD24}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CoopClient", "Client\CoopClient.csproj", "{EF56D109-1F22-43E0-9DFF-CFCFB94E0681}"
+EndProject
+Global
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution
+ Debug|x64 = Debug|x64
+ Release|x64 = Release|x64
+ EndGlobalSection
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution
+ {84AB99D9-5E00-4CA2-B1DD-56B8419AAD24}.Debug|x64.ActiveCfg = Debug|Any CPU
+ {84AB99D9-5E00-4CA2-B1DD-56B8419AAD24}.Debug|x64.Build.0 = Debug|Any CPU
+ {84AB99D9-5E00-4CA2-B1DD-56B8419AAD24}.Release|x64.ActiveCfg = Release|Any CPU
+ {84AB99D9-5E00-4CA2-B1DD-56B8419AAD24}.Release|x64.Build.0 = Release|Any CPU
+ {EF56D109-1F22-43E0-9DFF-CFCFB94E0681}.Debug|x64.ActiveCfg = Debug|Any CPU
+ {EF56D109-1F22-43E0-9DFF-CFCFB94E0681}.Debug|x64.Build.0 = Debug|Any CPU
+ {EF56D109-1F22-43E0-9DFF-CFCFB94E0681}.Release|x64.ActiveCfg = Release|Any CPU
+ {EF56D109-1F22-43E0-9DFF-CFCFB94E0681}.Release|x64.Build.0 = Release|Any CPU
+ EndGlobalSection
+ GlobalSection(SolutionProperties) = preSolution
+ HideSolutionNode = FALSE
+ EndGlobalSection
+ GlobalSection(ExtensibilityGlobals) = postSolution
+ SolutionGuid = {6CC7EA75-E4FF-4534-8EB6-0AEECF2620B7}
+ EndGlobalSection
+EndGlobal
diff --git a/Images/LOGO.png b/Images/LOGO.png
new file mode 100644
index 0000000000000000000000000000000000000000..42969280a0d11aca455d5a315fc99c7280d9c247
GIT binary patch
literal 108876
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