├── README.md
├── StrandardDeep Cheat.sln
└── StrandardDeep Cheat
    ├── BirdsESP.cs
    ├── BoarESP.cs
    ├── CrabESP.cs
    ├── FishesESP.cs
    ├── FoodESP.cs
    ├── FuelCanESP.cs
    ├── Loader.cs
    ├── Main.cs
    ├── Menu.cs
    ├── MiningRocksESP.cs
    ├── MissionBoardsESP.cs
    ├── Properties
        └── AssemblyInfo.cs
    ├── RaftESP.cs
    ├── Render.cs
    ├── ResourcesESP.cs
    ├── ResourcesESP1.cs
    ├── ResourcesESP2.cs
    ├── SharkESP.cs
    ├── SkinnableESP.cs
    ├── StrandardDeep Cheat.csproj
    └── WhaleESP.cs


/README.md:
--------------------------------------------------------------------------------
 1 | # Stranded-Deep-Mono-Cheat
 2 | [[My Website]](https://mitsuzi.xyz/)
 3 | 
 4 | # Features
 5 | #### Loot ESP
 6 | - Food
 7 | - Mining Rocks
 8 | - Raft
 9 | - Resources
10 | - Fuel Can
11 | - Distance
12 | 
13 | #### Entity ESP
14 | - Crab
15 | - Bird
16 | - Fish
17 | - Sharks
18 | - Skinnable
19 | - Whales
20 | - Boar
21 | - Distance
22 | 
23 | #### Others
24 | - Day Time Multiplier
25 | - Night Time Multiplayer
26 | - Missions Boards
27 | - Infinite Health
28 | - Infinite Hunger
29 | - Infinite Water
30 | - Infinite Sleep
31 | - Crosshair
32 | - NoClip
33 | - Infinite Oxygen
34 | - GodMode
35 | 
36 | #### Extra
37 | - Unload
38 | 
39 | # How To Use?
40 | Get A Mono Injector ( MInjector )
41 | Inject .dll Into the Game
42 | 
43 | # Settings
44 | - Namespace: StrandardDeep_Cheat
45 | - Class: Loader
46 | - Method: Load
47 | 
48 | Make sure to tick "Hide From AssemblyLoad Callback"
49 | 


--------------------------------------------------------------------------------
/StrandardDeep Cheat.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio 15
 4 | VisualStudioVersion = 15.0.27004.2009
 5 | MinimumVisualStudioVersion = 10.0.40219.1
 6 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "StrandardDeep Cheat", "StrandardDeep Cheat\StrandardDeep Cheat.csproj", "{2AD4988E-C0CF-4730-BD12-5A1D590CAD90}"
 7 | EndProject
 8 | Global
 9 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
10 | 		Debug|Any CPU = Debug|Any CPU
11 | 		Release|Any CPU = Release|Any CPU
12 | 	EndGlobalSection
13 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
14 | 		{2AD4988E-C0CF-4730-BD12-5A1D590CAD90}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
15 | 		{2AD4988E-C0CF-4730-BD12-5A1D590CAD90}.Debug|Any CPU.Build.0 = Debug|Any CPU
16 | 		{2AD4988E-C0CF-4730-BD12-5A1D590CAD90}.Release|Any CPU.ActiveCfg = Release|Any CPU
17 | 		{2AD4988E-C0CF-4730-BD12-5A1D590CAD90}.Release|Any CPU.Build.0 = Release|Any CPU
18 | 	EndGlobalSection
19 | 	GlobalSection(SolutionProperties) = preSolution
20 | 		HideSolutionNode = FALSE
21 | 	EndGlobalSection
22 | 	GlobalSection(ExtensibilityGlobals) = postSolution
23 | 		SolutionGuid = {4B73B31A-FC09-4546-A153-EA1BE27FD5EA}
24 | 	EndGlobalSection
25 | EndGlobal
26 | 


--------------------------------------------------------------------------------
/StrandardDeep Cheat/BirdsESP.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Collections;
 4 | using UnityEngine;
 5 | using Beam;
 6 | using Beam.AI;
 7 | 
 8 | namespace StrandardDeep_Cheat
 9 | {
10 |     public class BirdsESP : MonoBehaviour
11 |     {
12 |         private void Start()
13 |         {
14 | 
15 |         }
16 |         IEnumerator SleepFor(float Time)
17 |         {
18 |             yield return new WaitForSeconds(Time);
19 |         }
20 | 
21 |         Player localplayer = FindObjectsOfType<Player>()[0];
22 |         private void OnGUI()
23 |         {
24 |             if (Menu.EntityESP == true)
25 |             {
26 |                 if (Menu.BirdESP)
27 |                 {
28 |                     IEnumerable<Interactive_BIRD> playerProxies = FindObjectsOfType<Interactive_BIRD>();
29 |                     foreach (Interactive_BIRD playerProxy in playerProxies)
30 |                     {
31 | 
32 |                         Vector3 pos = playerProxy.transform.position;
33 |                         Vector3 posScreen = Camera.main.WorldToScreenPoint(pos);
34 | 
35 |                         if (posScreen.z > 0 & posScreen.y < Screen.width - 2)
36 |                         {
37 |                             float dist = Vector3.Distance(pos, localplayer.transform.position);
38 |                             if (dist < Menu.EntityDist)
39 |                             {
40 |                                 //Extremely useful
41 | 
42 |                                 //Interactive_FISHES proxyName = playerProxy.GetComponent<Interactive_FISHES>();
43 | 
44 | 
45 |                                 posScreen.y = Screen.height - (posScreen.y + 1f);
46 |                                 Render.DrawString(new Vector2(posScreen.x, posScreen.y), ("   Birds" + string.Format(" [{0:0}m]", (object)dist)), Color.green);
47 |                             }
48 |                         }
49 |                         SleepFor(0.300f);
50 |                     }
51 |                     SleepFor(0.300f);
52 |                 }
53 |                 SleepFor(0.300f);
54 | 
55 |             }
56 |         }
57 | 
58 | 
59 |         private void Update()
60 |         {
61 | 
62 |         }
63 |     }
64 | }
65 | 


--------------------------------------------------------------------------------
/StrandardDeep Cheat/BoarESP.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Collections;
 4 | using UnityEngine;
 5 | using Beam;
 6 | using Beam.AI;
 7 | 
 8 | namespace StrandardDeep_Cheat
 9 | {
10 |     public class BoarESP : MonoBehaviour
11 |     {
12 |         private void Start()
13 |         {
14 | 
15 |         }
16 |         IEnumerator SleepFor(float Time)
17 |         {
18 |             yield return new WaitForSeconds(Time);
19 |         }
20 | 
21 |         Player localplayer = FindObjectsOfType<Player>()[0];
22 |         private void OnGUI()
23 |         {
24 |             if (Menu.EntityESP == true)
25 |             {
26 |                 if (Menu.BoarESP)
27 |                 {
28 |                     IEnumerable<InteractiveObject_BOAR> playerProxies = FindObjectsOfType<InteractiveObject_BOAR>();
29 |                     foreach (InteractiveObject_BOAR playerProxy in playerProxies)
30 |                     {
31 | 
32 |                         Vector3 pos = playerProxy.transform.position;
33 |                         Vector3 posScreen = Camera.main.WorldToScreenPoint(pos);
34 | 
35 |                         if (posScreen.z > 0 & posScreen.y < Screen.width - 2)
36 |                         {
37 |                             float dist = Vector3.Distance(pos, localplayer.transform.position);
38 |                             if (dist < Menu.EntityDist)
39 |                             {
40 |                                 //Extremely useful
41 | 
42 |                                 posScreen.y = Screen.height - (posScreen.y + 1f);
43 |                                 Render.DrawString(new Vector2(posScreen.x, posScreen.y), ("   Boar" + string.Format(" [{0:0}m]", (object)dist)), Color.green);
44 |                             }
45 |                         }
46 |                         SleepFor(0.300f);
47 |                     }
48 |                     SleepFor(0.300f);
49 |                 }
50 |                 SleepFor(0.300f);
51 | 
52 |             }
53 |         }
54 | 
55 | 
56 |         private void Update()
57 |         {
58 | 
59 |         }
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/StrandardDeep Cheat/CrabESP.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Collections;
 4 | using UnityEngine;
 5 | using Beam;
 6 | using Beam.AI;
 7 | 
 8 | namespace StrandardDeep_Cheat
 9 | {
10 |     public class CrabESP : MonoBehaviour
11 |     {
12 |         private void Start()
13 |         {
14 | 
15 |         }
16 |         IEnumerator SleepFor(float Time)
17 |         {
18 |             yield return new WaitForSeconds(Time);
19 |         }
20 | 
21 |         Player localplayer = FindObjectsOfType<Player>()[0];
22 |         private void OnGUI()
23 |         {
24 |             if (Menu.EntityESP == true)
25 |             {
26 |                 if (Menu.CrabESP)
27 |                 {
28 |                     IEnumerable<InteractiveObject_CRAB> playerProxies = FindObjectsOfType<InteractiveObject_CRAB>();
29 |                     foreach (InteractiveObject_CRAB playerProxy in playerProxies)
30 |                     {
31 |                         
32 |                         Vector3 pos = playerProxy.transform.position;
33 |                         float dist = Vector3.Distance(pos, localplayer.transform.position);
34 |                         if (dist < Menu.EntityDist)
35 |                         {
36 |                             //Extremely useful
37 |                             Vector3 posScreen = Camera.main.WorldToScreenPoint(pos);
38 | 
39 |                             if (posScreen.z > 0 & posScreen.y < Screen.width - 2)
40 |                             {
41 |                                 posScreen.y = Screen.height - (posScreen.y + 1f);
42 |                                 Render.DrawString(new Vector2(posScreen.x, posScreen.y), ("   Crab" + string.Format(" [{0:0}m]", (object)dist)), Color.green);
43 |                             }
44 |                         }
45 |                         SleepFor(0.300f);
46 |                     }
47 |                     SleepFor(0.300f);
48 |                 }
49 |                 SleepFor(0.300f);
50 | 
51 |             }
52 |         }
53 | 
54 | 
55 |         private void Update()
56 |         {
57 | 
58 |         }
59 |     }
60 | }
61 | 


--------------------------------------------------------------------------------
/StrandardDeep Cheat/FishesESP.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Collections;
 4 | using UnityEngine;
 5 | using Beam;
 6 | using Beam.AI;
 7 | 
 8 | namespace StrandardDeep_Cheat
 9 | {
10 |     public class FishesESP : MonoBehaviour
11 |     {
12 |         private void Start()
13 |         {
14 | 
15 |         }
16 |         IEnumerator SleepFor(float Time)
17 |         {
18 |             yield return new WaitForSeconds(Time);
19 |         }
20 | 
21 |         Player localplayer = FindObjectsOfType<Player>()[0];
22 |         private void OnGUI()
23 |         {
24 |             if (Menu.EntityESP == true)
25 |             {
26 |                 if (Menu.FishESP)
27 |                 {
28 |                     IEnumerable<Interactive_FISHES> playerProxies = FindObjectsOfType<Interactive_FISHES>();
29 |                     foreach (Interactive_FISHES playerProxy in playerProxies)
30 |                     {
31 |                         
32 |                         Vector3 pos = playerProxy.transform.position;
33 |                         float dist = Vector3.Distance(pos, localplayer.transform.position);
34 |                         if (dist < Menu.EntityDist)
35 |                         {
36 |                             //Extremely useful
37 |                             Vector3 posScreen = Camera.main.WorldToScreenPoint(pos);
38 | 
39 |                             if (posScreen.z > 0 & posScreen.y < Screen.width - 2)
40 |                             {
41 |                                 posScreen.y = Screen.height - (posScreen.y + 1f);
42 |                                 Render.DrawString(new Vector2(posScreen.x, posScreen.y), ("   Fish" + string.Format(" [{0:0}m]", (object)dist)), Color.green);
43 |                             }
44 |                         }
45 |                         SleepFor(0.300f);
46 |                     }
47 |                     SleepFor(0.300f);
48 |                 }
49 |                 SleepFor(0.300f);
50 | 
51 |             }
52 |         }
53 | 
54 | 
55 |         private void Update()
56 |         {
57 | 
58 |         }
59 | 
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/StrandardDeep Cheat/FoodESP.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Collections;
 4 | using UnityEngine;
 5 | using Beam;
 6 | using Beam.AI;
 7 | 
 8 | namespace StrandardDeep_Cheat
 9 | {
10 |     public class FoodESP : MonoBehaviour
11 |     {
12 |         private void Start()
13 |         {
14 | 
15 |         }
16 |         IEnumerator SleepFor(float Time)
17 |         {
18 |             yield return new WaitForSeconds(Time);
19 |         }
20 | 
21 |         Player localplayer = FindObjectsOfType<Player>()[0];
22 |         private void OnGUI()
23 |         {
24 |             if (Menu.LootESP == true)
25 |             {
26 |                 if (Menu.FoodESP)
27 |                 {
28 |                     IEnumerable<InteractiveObject_FOOD> playerProxies = FindObjectsOfType<InteractiveObject_FOOD>();
29 |                     foreach (InteractiveObject_FOOD playerProxy in playerProxies)
30 |                     {
31 |                        
32 |                         Vector3 pos = playerProxy.transform.position;
33 |                         Vector3 posScreen = Camera.main.WorldToScreenPoint(pos);
34 | 
35 |                         if (posScreen.z > 0 & posScreen.y < Screen.width - 2)
36 |                         {
37 |                             float dist = Vector3.Distance(pos, localplayer.transform.position);
38 |                             if (dist < Menu.LoopDist)
39 |                             {
40 |                                 posScreen.y = Screen.height - (posScreen.y + 1f);
41 |                                 Render.DrawString(new Vector2(posScreen.x, posScreen.y), ("   Food" + string.Format(" [{0:0}m]", (object)dist)), Color.green);
42 |                             }
43 |                         }
44 |                         SleepFor(0.300f);
45 |                     }
46 |                     SleepFor(0.300f);
47 |                 }
48 |                 SleepFor(0.300f);
49 | 
50 |             }
51 |         }
52 | 
53 | 
54 |         private void Update()
55 |         {
56 | 
57 |         }
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/StrandardDeep Cheat/FuelCanESP.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Collections;
 4 | using UnityEngine;
 5 | using Beam;
 6 | using Beam.AI;
 7 | 
 8 | namespace StrandardDeep_Cheat
 9 | {
10 |     public class FuelCanESP : MonoBehaviour
11 |     {
12 |         private void Start()
13 |         {
14 | 
15 |         }
16 |         IEnumerator SleepFor(float Time)
17 |         {
18 |             yield return new WaitForSeconds(Time);
19 |         }
20 | 
21 |         Player localplayer = FindObjectsOfType<Player>()[0];
22 |         private void OnGUI()
23 |         {
24 |             if (Menu.LootESP == true)
25 |             {
26 |                 if (Menu.FuelCanESP)
27 |                 {
28 |                     IEnumerable<InteractiveObject_FUELCAN> playerProxies = FindObjectsOfType<InteractiveObject_FUELCAN>();
29 |                     foreach (InteractiveObject_FUELCAN playerProxy in playerProxies)
30 |                     {
31 | 
32 |                         Vector3 pos = playerProxy.transform.position;
33 |                         Vector3 posScreen = Camera.main.WorldToScreenPoint(pos);
34 | 
35 |                         if (posScreen.z > 0 & posScreen.y < Screen.width - 2)
36 |                         {
37 |                             float dist = Vector3.Distance(pos, localplayer.transform.position);
38 |                             if (dist < Menu.LoopDist)
39 |                             {
40 | 
41 |                                 posScreen.y = Screen.height - (posScreen.y + 1f);
42 |                                 Render.DrawString(new Vector2(posScreen.x, posScreen.y), ("   Fuel Can" + string.Format(" [{0:0}m]", (object)dist)), Color.green);
43 |                             }
44 |                         }
45 |                         SleepFor(0.300f);
46 |                     }
47 |                     SleepFor(0.300f);
48 |                 }
49 |                 SleepFor(0.300f);
50 | 
51 |             }
52 |         }
53 | 
54 | 
55 |         private void Update()
56 |         {
57 | 
58 |         }
59 |     }
60 | }
61 | 


--------------------------------------------------------------------------------
/StrandardDeep Cheat/Loader.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Linq;
 4 | using System.Text;
 5 | using System.Threading.Tasks;
 6 | using UnityEngine;
 7 | 
 8 | namespace StrandardDeep_Cheat
 9 | {
10 |     // Token: 0x02000005 RID: 5
11 |     public class Loader : MonoBehaviour
12 |     {
13 |         // Token: 0x06000019 RID: 25 RVA: 0x000027E8 File Offset: 0x000009E8
14 |         public static void Load()
15 |         {
16 |             Loader._loadObject = new GameObject();
17 |             Loader._loadObject.AddComponent<Main>();
18 |             Loader._loadObject.AddComponent<Menu>();
19 |             Loader._loadObject.AddComponent<CrabESP>();
20 |             Loader._loadObject.AddComponent<BirdsESP>();
21 |             Loader._loadObject.AddComponent<FishesESP>();
22 |             Loader._loadObject.AddComponent<SharkESP>();
23 |             Loader._loadObject.AddComponent<SkinnableESP>();
24 |             Loader._loadObject.AddComponent<WhaleESP>();
25 |             Loader._loadObject.AddComponent<FoodESP>();
26 |             Loader._loadObject.AddComponent<MiningRocksESP>();
27 |             Loader._loadObject.AddComponent<RaftESP>();
28 |             Loader._loadObject.AddComponent<ResourcesHARVESTPLANTESP>();
29 |             Loader._loadObject.AddComponent<ResourcesHARVESTRESOURCEESP>();
30 |             Loader._loadObject.AddComponent<ResourcesPALM_LOGESP>();
31 |             Loader._loadObject.AddComponent<FuelCanESP>();
32 |             Loader._loadObject.AddComponent<BoarESP>();
33 |             Loader._loadObject.AddComponent<MissionBoardsESP>();
34 |             //Loader._loadObject.AddComponent<PickupESP>();
35 |             GameObject.DontDestroyOnLoad(Loader._loadObject);
36 |         }
37 | 
38 |         // Token: 0x0600001B RID: 27 RVA: 0x0000288C File Offset: 0x00000A8C
39 |         public static void Unload()
40 |         {
41 |             Loader._Unload();
42 |         }
43 | 
44 |         // Token: 0x0600001C RID: 28 RVA: 0x00002894 File Offset: 0x00000A94
45 |         private static void _Unload()
46 |         {
47 |             GameObject.Destroy(Loader._loadObject);
48 |         }
49 | 
50 |         // Token: 0x04000001 RID: 1
51 |         public static GameObject _loadObject;
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/StrandardDeep Cheat/Main.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using System.Collections.Generic;
  3 | using System.Linq;
  4 | using System.Text;
  5 | using System.Threading.Tasks;
  6 | using UnityEngine;
  7 | using UnityEngine.UI;
  8 | using Beam;
  9 | 
 10 | namespace StrandardDeep_Cheat
 11 | {
 12 |     public class Main : MonoBehaviour
 13 |     {
 14 |         public static bool AdvancedGodMode { private get; set; }
 15 | 
 16 |         // Token: 0x06000031 RID: 49 RVA: 0x000036E0 File Offset: 0x000018E0
 17 |         private static void SwitchMode()
 18 |         {
 19 |             Singleton<DeveloperMode>.Instance.SwitchModes();
 20 |             Singleton<DeveloperMode>.Instance.startInFlyMode = !Singleton<DeveloperMode>.Instance.InFlyMode;
 21 |             if (Singleton<DeveloperMode>.Instance.startInFlyMode)
 22 |             {
 23 |                 Shader.SetGlobalFloat("_BelowVisibility", 100f);
 24 |             }
 25 |             Physics.IgnoreLayerCollision(Layers.PLAYER, Layers.TERRAIN_OBJECTS, true);
 26 |             Physics.IgnoreLayerCollision(Layers.PLAYER, Layers.TERRAIN, true);
 27 |             Physics.IgnoreLayerCollision(Layers.PLAYER, Layers.CONSTRUCTIONS, true);
 28 |             Physics.IgnoreLayerCollision(Layers.PLAYER, Layers.INTERACTIVE_TREES, true);
 29 |             Physics.IgnoreLayerCollision(Layers.PLAYER, Layers.INTERACTIVE_OBJECTS, true);
 30 |             Physics.IgnoreLayerCollision(Layers.PLAYER, Layers.CONSTRUCTIONS_SMALL, true);
 31 |             Physics.IgnoreLayerCollision(Layers.PLAYER, Layers.CONSTRUCTIONS_RAFTS, true);
 32 | 
 33 | 
 34 |         }
 35 | 
 36 |         private void Initialize()
 37 |         {
 38 |             
 39 |         }
 40 |         private void Awake()
 41 |         {
 42 |             this.toggles = base.GetComponentsInChildren<Toggle>();
 43 |             this.Initialize();
 44 |         }
 45 | 
 46 |         private void Start()
 47 |         {
 48 |             
 49 |         }
 50 |         private void Update()
 51 |         {
 52 |             if (Menu.NoClip)
 53 |             {
 54 |                 if (Input.GetKey(KeyCode.F1))
 55 |                 {
 56 |                     Main.SwitchMode();
 57 |                 }
 58 |             }
 59 |             else
 60 |             {
 61 |                 Physics.IgnoreLayerCollision(Layers.PLAYER, Layers.TERRAIN_OBJECTS, false);
 62 |                 Physics.IgnoreLayerCollision(Layers.PLAYER, Layers.TERRAIN, false);
 63 |                 Physics.IgnoreLayerCollision(Layers.PLAYER, Layers.CONSTRUCTIONS, false);
 64 |                 Physics.IgnoreLayerCollision(Layers.PLAYER, Layers.INTERACTIVE_TREES, false);
 65 |                 Physics.IgnoreLayerCollision(Layers.PLAYER, Layers.INTERACTIVE_OBJECTS, false);
 66 |                 Physics.IgnoreLayerCollision(Layers.PLAYER, Layers.CONSTRUCTIONS_SMALL, false);
 67 |                 Physics.IgnoreLayerCollision(Layers.PLAYER, Layers.CONSTRUCTIONS_RAFTS, false);
 68 |             }
 69 |            
 70 |            if ( Menu.InfiniteOxygen)
 71 |             {
 72 |                 if (Game.State == GameState.MAIN_MENU)
 73 |                 {
 74 |                     return;
 75 |                 }
 76 |                 if (Singleton<CetoSettings>.Instance == null)
 77 |                 {
 78 |                     return;
 79 |                 }
 80 |                 if (PlayerRegistry.LocalPlayer == null)
 81 |                 {
 82 |                     return;
 83 |                 }
 84 |                 if (PlayerRegistry.LocalPlayer.Movement == null)
 85 |                 {
 86 |                     return;
 87 |                 }
 88 |                 if (!PlayerRegistry.LocalPlayer.Movement.inWater)
 89 |                 {
 90 |                     return;
 91 |                 }
 92 |                 float num = UnityEngine.Random.Range(16f, 20f);
 93 |                 if (PlayerRegistry.LocalPlayer.Statistics.Oxygen < PlayerRegistry.LocalPlayer.Statistics.MaxOxygen - num && PlayerRegistry.LocalPlayer.Movement.IsUnderwater && !PlayerRegistry.LocalPlayer.Movement.isFloating)
 94 |                 {
 95 |                     PlayerRegistry.LocalPlayer.Statistics.AddOxygen(num);
 96 |                 }
 97 |             }
 98 |            if (Input.GetKey(KeyCode.F12))
 99 |             {
100 |                 Loader.Unload();
101 |             }
102 | 
103 |             if (this.DayTime)
104 |             {
105 |                 if (Menu.DayTimeMultiplier == 1)
106 |                 {
107 |                     this.toggles[0].isOn = true;
108 |                     return;
109 |                 }
110 |                 if (Menu.DayTimeMultiplier == 2)
111 |                 {
112 |                     this.toggles[1].isOn = true;
113 |                     return;
114 |                 }
115 |                 if (Menu.DayTimeMultiplier == 3)
116 |                 {
117 |                     this.toggles[2].isOn = true;
118 |                     return;
119 |                 }
120 |                 if (Menu.DayTimeMultiplier == 4)
121 |                 {
122 |                     this.toggles[3].isOn = true;
123 |                     return;
124 |                 }
125 |                 if (Menu.DayTimeMultiplier == 5)
126 |                 {
127 |                     this.toggles[4].isOn = true;
128 |                     return;
129 |                 }
130 |                 if (Menu.DayTimeMultiplier == 6)
131 |                 {
132 |                     this.toggles[5].isOn = true;
133 |                     return;
134 |                 }
135 |             }
136 |             else
137 |             {
138 |                 if (Menu.NightTimeMultiplier == 1)
139 |                 {
140 |                     this.toggles[0].isOn = true;
141 |                     return;
142 |                 }
143 |                 if (Menu.NightTimeMultiplier == 2)
144 |                 {
145 |                     this.toggles[1].isOn = true;
146 |                     return;
147 |                 }
148 |                 if (Menu.NightTimeMultiplier == 3)
149 |                 {
150 |                     this.toggles[2].isOn = true;
151 |                     return;
152 |                 }
153 |                 if (Menu.NightTimeMultiplier == 4)
154 |                 {
155 |                     this.toggles[3].isOn = true;
156 |                     return;
157 |                 }
158 |                 if (Menu.NightTimeMultiplier == 5)
159 |                 {
160 |                     this.toggles[4].isOn = true;
161 |                     return;
162 |                 }
163 |                 if (Menu.NightTimeMultiplier == 6)
164 |                 {
165 |                     this.toggles[5].isOn = true;
166 |                 }
167 |             }
168 | 
169 |         }
170 |         
171 |         private void FixedUpdate()
172 |         {
173 |             if (Menu.InfiniteHealth)
174 |             {
175 |                 PlayerRegistry.LocalPlayer.Statistics.AddHealth(100);
176 |             }
177 |             if (Menu.InfiniteHunger)
178 |             {
179 |                 PlayerRegistry.LocalPlayer.Statistics.Eat(InteractiveType.FOOD_CAN_BEANS, 1000);
180 |             }
181 |             if (Menu.InfiniteSleep)
182 |             {
183 |                 PlayerRegistry.LocalPlayer.Statistics._sleep = 100;
184 |             }
185 |             if (Menu.GodMode)
186 |             {
187 |                 PlayerRegistry.LocalPlayer.Statistics.Invincible = true;
188 |             }
189 |             else
190 |             {
191 |                 PlayerRegistry.LocalPlayer.Statistics.Invincible = false;
192 |             }
193 | 
194 |         }
195 |         private void OnGUI()
196 |         {
197 |             
198 |             if (Menu.Crosshair)
199 |             {
200 |                 
201 | 
202 |                 Render.DrawBox(new Vector2((float)Screen.width / 2f, (float)Screen.height / 2f - 7f), new Vector2(1,15), Color.yellow);
203 |                 Render.DrawBox(new Vector2((float)Screen.width / 2f - 7f, (float)Screen.height / 2f), new Vector2(15, 1), Color.yellow);
204 |             }
205 |         }
206 | 
207 |         public bool DayTime;
208 | 
209 |         // Token: 0x0400009F RID: 159
210 |         private Toggle[] toggles;
211 |     }
212 | }
213 | 
214 | 


--------------------------------------------------------------------------------
/StrandardDeep Cheat/Menu.cs:
--------------------------------------------------------------------------------
  1 | using System;
  2 | using UnityEngine;
  3 | using System.Collections.Generic;
  4 | using System.Linq;
  5 | using Beam.Events;
  6 | using Beam.UI;
  7 | using Beam;
  8 | 
  9 | namespace StrandardDeep_Cheat
 10 | {
 11 |     public class Menu : MonoBehaviour
 12 |     {
 13 |         // Token: 0x0600004A RID: 74 RVA: 0x00003B24 File Offset: 0x00001D24
 14 |         public void Start()
 15 |         {
 16 |             this._window = new Rect(10f, 10f, 250f, 150f);
 17 |             this._window2 = new Rect(10f, 10f, 250f, 150f);
 18 |             this._window3 = new Rect(10f, 10f, 250f, 150f);
 19 |             this._window4 = new Rect(10f, 10f, 250f, 150f);
 20 |         }
 21 | 
 22 |         // Token: 0x0600004B RID: 75 RVA: 0x00003B90 File Offset: 0x00001D90
 23 |         private void Update()
 24 |         {
 25 |             if (Input.GetKeyDown(KeyCode.Home))
 26 |             {
 27 |                 this.Visible = !this.Visible;
 28 |             }
 29 | 
 30 |         }
 31 | 
 32 |         // Token: 0x0600004C RID: 76 RVA: 0x00003BB0 File Offset: 0x00001DB0
 33 |         public void OnGUI()
 34 |         {
 35 |             if (!this.Visible)
 36 |             {
 37 |                 return;
 38 |             }
 39 |             this._window = GUILayout.Window(0, this._window, new GUI.WindowFunction(this.Draw), "Stranded Deep (HOME)", new GUILayoutOption[0]);
 40 |             if (this.OptionsVisible)
 41 |             {
 42 |                 this._window2 = GUILayout.Window(1, this._window2, new GUI.WindowFunction(this.DrawESPOptions), "Entity Options", new GUILayoutOption[0]);
 43 |             }
 44 |             if (this.ItemsVisible)
 45 |             {
 46 |                 this._window3 = GUILayout.Window(2, this._window3, new GUI.WindowFunction(this.DrawAvailablePickups), "Loot options", new GUILayoutOption[0]);
 47 |             }
 48 |             if (this.OtherVisible)
 49 |             {
 50 |                 this._window4 = GUILayout.Window(3, this._window4, new GUI.WindowFunction(this.DrawOtherOptions), "Other options", new GUILayoutOption[0]);
 51 |             }
 52 |         }
 53 | 
 54 |         public void Draw(int id)
 55 |         {
 56 |             Menu.LootESP = GUILayout.Toggle(Menu.LootESP, "Loot ESP", new GUILayoutOption[0]);
 57 |             GUILayout.Label(string.Format("Loot Distance: {0}", Menu.LoopDist), new GUILayoutOption[0]);
 58 |             Menu.LoopDist = Mathf.Round(GUILayout.HorizontalSlider(Menu.LoopDist, 0f, 5000f, new GUILayoutOption[0]) * 5000f) / 5000f;
 59 |             Menu.EntityESP = GUILayout.Toggle(Menu.EntityESP, "Entity ESP", new GUILayoutOption[0]);
 60 |             GUILayout.Label(string.Format("Entity Distance: {0}", Menu.EntityDist), new GUILayoutOption[0]);
 61 |             Menu.EntityDist = Mathf.Round(GUILayout.HorizontalSlider(Menu.EntityDist, 0f, 5000f, new GUILayoutOption[0]) * 5000f) / 5000f;
 62 |             GUILayout.Space(10f);
 63 |             Menu.Crosshair = GUILayout.Toggle(Menu.Crosshair, "CrossHair", new GUILayoutOption[0]);
 64 |             Menu.NoClip = GUILayout.Toggle(Menu.NoClip, "No Clip (F1 Switch modes)", new GUILayoutOption[0]);
 65 |             Menu.InfiniteOxygen = GUILayout.Toggle(Menu.InfiniteOxygen, "Infinite Oxygen", new GUILayoutOption[0]);
 66 |             Menu.GodMode = GUILayout.Toggle(Menu.GodMode, "GodMode", new GUILayoutOption[0]);
 67 |             if (GUILayout.Button("Entity Options", new GUILayoutOption[0]))
 68 |             {
 69 |                 this._window2.x = this._window.width + 20f;
 70 |                 this.OptionsVisible = !this.OptionsVisible;
 71 |             }
 72 | 
 73 |             if (GUILayout.Button("Loot options", new GUILayoutOption[0]))
 74 |             {
 75 |                 this._window3.x = this._window2.width + 300f;
 76 |                 this.ItemsVisible = !this.ItemsVisible;
 77 |             }
 78 |             if (GUILayout.Button("Other options", new GUILayoutOption[0]))
 79 |             {
 80 |                 this._window4.x = this._window3.width + 20f;
 81 |                 this._window4.y = this._window3.width + 100f;
 82 |                 this.OtherVisible = !this.OtherVisible;
 83 |             }
 84 |             if (GUILayout.Button("Unload", new GUILayoutOption[0]))
 85 |             {
 86 |                 Loader.Unload();
 87 |             }
 88 |             GUI.DragWindow();
 89 |         }
 90 | 
 91 |         public void DrawOtherOptions(int id)
 92 |         {
 93 |             GUILayout.Label("Other Options:", new GUILayoutOption[0]);
 94 |             GUILayout.Space(-5f);
 95 |             GUILayout.Label(string.Format("Day Time Multiplier: {0}", Menu.DayTimeMultiplier), new GUILayoutOption[0]);
 96 |             Menu.DayTimeMultiplier = (int)(GUILayout.HorizontalSlider((int)DayTimeMultiplier, (int)0, (int)6, new GUILayoutOption[(int)0]) * (int)6 / (int)6);
 97 | 
 98 |             GUILayout.Label(string.Format("Night Time Multiplier: {0}", Menu.NightTimeMultiplier), new GUILayoutOption[0]);
 99 |             Menu.NightTimeMultiplier = (int)(GUILayout.HorizontalSlider((int)NightTimeMultiplier, (int)0, (int)6, new GUILayoutOption[(int)0]) * (int)6 / (int)6);
100 |             GUILayout.Space(-5f);
101 |             Menu.MissionBoardsESP = GUILayout.Toggle(Menu.MissionBoardsESP, "Mission Boards", new GUILayoutOption[0]);
102 | 
103 |             Menu.InfiniteHealth = GUILayout.Toggle(Menu.InfiniteHealth, "Infinite Health", new GUILayoutOption[0]);
104 |             Menu.InfiniteHunger = GUILayout.Toggle(Menu.InfiniteHunger, "Infinite Hunger", new GUILayoutOption[0]);
105 |             Menu.InfiniteWater = GUILayout.Toggle(Menu.InfiniteWater, "Infinite Water", new GUILayoutOption[0]);
106 |             Menu.InfiniteSleep = GUILayout.Toggle(Menu.InfiniteSleep, "Infinite Sleep", new GUILayoutOption[0]);
107 | 
108 |             GUI.DragWindow();
109 | 
110 |         }
111 | 
112 |         public void DrawESPOptions(int id)
113 |         {
114 |             GUILayout.Label("Entity Options:", new GUILayoutOption[0]);
115 |             GUILayout.Space(-5f);
116 |             Menu.CrabESP = GUILayout.Toggle(Menu.CrabESP, "Crab", new GUILayoutOption[0]);
117 |             Menu.BirdESP = GUILayout.Toggle(Menu.BirdESP, "Bird", new GUILayoutOption[0]);
118 |             Menu.FishESP = GUILayout.Toggle(Menu.FishESP, "Fishes", new GUILayoutOption[0]);
119 |             Menu.sharkESP = GUILayout.Toggle(Menu.sharkESP, "Sharks", new GUILayoutOption[0]);
120 |             Menu.SkinnableESP = GUILayout.Toggle(Menu.SkinnableESP, "Skinnable", new GUILayoutOption[0]);
121 |             Menu.WhaleESP = GUILayout.Toggle(Menu.WhaleESP, "Whale", new GUILayoutOption[0]);
122 |             Menu.BoarESP = GUILayout.Toggle(Menu.BoarESP, "Boar", new GUILayoutOption[0]);
123 |             GUI.DragWindow();
124 |         }
125 | 
126 | 
127 |         public void DrawAvailablePickups(int id)
128 |         {
129 |             GUILayout.Label("Loot Options:", new GUILayoutOption[0]);
130 |             GUILayout.Space(-5f);
131 |             Menu.FoodESP = GUILayout.Toggle(Menu.FoodESP, "Food", new GUILayoutOption[0]);
132 |             Menu.MiningRocksESP = GUILayout.Toggle(Menu.MiningRocksESP, "Mining Rocks", new GUILayoutOption[0]);
133 |             Menu.RaftESP = GUILayout.Toggle(Menu.RaftESP, "Raft", new GUILayoutOption[0]);
134 |             Menu.ResourcesESP = GUILayout.Toggle(Menu.ResourcesESP, "Resources", new GUILayoutOption[0]);
135 |             Menu.FuelCanESP = GUILayout.Toggle(Menu.FuelCanESP, "Fuel Can", new GUILayoutOption[0]);
136 |             GUI.DragWindow();
137 |         }
138 | 
139 |         // Token: 0x04000032 RID: 50
140 |         public bool Visible = true;
141 | 
142 |         // Token: 0x04000032 RID: 50
143 |         public bool OptionsVisible = false;
144 | 
145 |         // Token: 0x04000032 RID: 50
146 |         public bool ItemsVisible = false;
147 | 
148 |         // Token: 0x04000032 RID: 50
149 |         public bool OtherVisible = false;
150 | 
151 |         // Token: 0x04000035 RID: 53
152 |         private Rect _window;
153 | 
154 |         // Token: 0x04000036 RID: 54
155 |         private Rect _window2;
156 | 
157 |         // Token: 0x04000037 RID: 55
158 |         private Rect _window3;
159 | 
160 |         private Rect _window4;
161 | 
162 |         public static int DayTimeMultiplier = 0;
163 |         public static int NightTimeMultiplier = 0;
164 |         public static bool MissionBoardsESP = false;
165 |         public static bool InfiniteHealth = false;
166 |         public static bool InfiniteHunger = false;
167 |         public static bool InfiniteWater = false;
168 |         public static bool InfiniteSleep = false;
169 | 
170 |         public static bool CrabESP = false;
171 |         public static bool BirdESP = false;
172 |         public static bool FishESP = false;
173 |         public static bool sharkESP = false;
174 |         public static bool WhaleESP = false;
175 |         public static bool SkinnableESP = false;
176 |         public static bool BoarESP = false;
177 | 
178 |         public static bool ResourcesESP = false;
179 |         public static bool FuelCanESP = false;
180 |         public static bool RaftESP = false;
181 |         public static bool MiningRocksESP = false;
182 |         public static bool FoodESP = false;
183 | 
184 |         public static float LoopDist = 10;
185 |         public static float EntityDist = 10;
186 |         public static bool InfiniteOxygen = false;
187 |         public static bool NoClip = false;
188 |         public static bool GodMode = false;
189 |         public static bool Crosshair = true;
190 |         public static bool EntityESP = false;
191 |         public static bool LootESP = false;
192 |     }
193 | }
194 | 


--------------------------------------------------------------------------------
/StrandardDeep Cheat/MiningRocksESP.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Collections;
 4 | using UnityEngine;
 5 | using Beam;
 6 | using Beam.AI;
 7 | 
 8 | namespace StrandardDeep_Cheat
 9 | {
10 |     public class MiningRocksESP : MonoBehaviour
11 |     {
12 |         private void Start()
13 |         {
14 | 
15 |         }
16 |         IEnumerator SleepFor(float Time)
17 |         {
18 |             yield return new WaitForSeconds(Time);
19 |         }
20 | 
21 |         Player localplayer = FindObjectsOfType<Player>()[0];
22 |         private void OnGUI()
23 |         {
24 |             if (Menu.LootESP == true)
25 |             {
26 |                 if (Menu.MiningRocksESP)
27 |                 {
28 |                     IEnumerable<InteractiveObject_MININGROCK> playerProxies = FindObjectsOfType<InteractiveObject_MININGROCK>();
29 |                     foreach (InteractiveObject_MININGROCK playerProxy in playerProxies)
30 |                     {
31 |                        
32 |                         Vector3 pos = playerProxy.transform.position;
33 |                         Vector3 posScreen = Camera.main.WorldToScreenPoint(pos);
34 | 
35 |                         if (posScreen.z > 0 & posScreen.y < Screen.width - 2)
36 |                         {
37 |                             float dist = Vector3.Distance(pos, localplayer.transform.position);
38 |                             if (dist < Menu.LoopDist)
39 |                             {
40 |                                 posScreen.y = Screen.height - (posScreen.y + 1f);
41 |                                 Render.DrawString(new Vector2(posScreen.x, posScreen.y), (" Mining Rocks" + string.Format(" [{0:0}m]", (object)dist)), Color.green);
42 |                             }
43 |                         }
44 |                         SleepFor(0.300f);
45 |                     }
46 |                     SleepFor(0.300f);
47 |                 }
48 |                 SleepFor(0.300f);
49 | 
50 |             }
51 |         }
52 | 
53 | 
54 |         private void Update()
55 |         {
56 | 
57 |         }
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/StrandardDeep Cheat/MissionBoardsESP.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Collections;
 4 | using UnityEngine;
 5 | using Beam;
 6 | using Beam.AI;
 7 | 
 8 | namespace StrandardDeep_Cheat
 9 | {
10 |     public class MissionBoardsESP : MonoBehaviour
11 |     {
12 |         private void Start()
13 |         {
14 | 
15 |         }
16 |         IEnumerator SleepFor(float Time)
17 |         {
18 |             yield return new WaitForSeconds(Time);
19 |         }
20 | 
21 |         Player localplayer = FindObjectsOfType<Player>()[0];
22 |         private void OnGUI()
23 |         {
24 | 
25 |             if (Menu.MissionBoardsESP)
26 |             {
27 |                 IEnumerable<InteractiveMissionTrigger> playerProxies = FindObjectsOfType<InteractiveMissionTrigger>();
28 |                 foreach (InteractiveMissionTrigger playerProxy in playerProxies)
29 |                 {
30 | 
31 |                     Vector3 pos = playerProxy.transform.position;
32 |                     //Extremely useful
33 |                     Vector3 posScreen = Camera.main.WorldToScreenPoint(pos);
34 | 
35 |                     if (posScreen.z > 0 & posScreen.y < Screen.width - 2)
36 |                     {
37 |                         float dist = Vector3.Distance(pos, localplayer.transform.position);
38 |                         if (dist < Menu.LoopDist)
39 |                         {
40 |                             posScreen.y = Screen.height - (posScreen.y + 1f);
41 |                             Render.DrawString(new Vector2(posScreen.x, posScreen.y), (" Mission Board" + string.Format(" [{0:0}m]", (object)dist)), Color.green);
42 |                         }
43 |                     }
44 |                     SleepFor(0.300f);
45 |                 }
46 |                 SleepFor(0.300f);
47 |             }
48 |             SleepFor(0.300f);
49 | 
50 | 
51 |         }
52 | 
53 | 
54 |         private void Update()
55 |         {
56 | 
57 |         }
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/StrandardDeep Cheat/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
 1 | using System.Reflection;
 2 | using System.Runtime.CompilerServices;
 3 | using System.Runtime.InteropServices;
 4 | 
 5 | // General Information about an assembly is controlled through the following
 6 | // set of attributes. Change these attribute values to modify the information
 7 | // associated with an assembly.
 8 | [assembly: AssemblyTitle("StrandardDeep Cheat")]
 9 | [assembly: AssemblyDescription("")]
10 | [assembly: AssemblyConfiguration("")]
11 | [assembly: AssemblyCompany("")]
12 | [assembly: AssemblyProduct("StrandardDeep Cheat")]
13 | [assembly: AssemblyCopyright("Copyright ©  2018")]
14 | [assembly: AssemblyTrademark("")]
15 | [assembly: AssemblyCulture("")]
16 | 
17 | // Setting ComVisible to false makes the types in this assembly not visible
18 | // to COM components.  If you need to access a type in this assembly from
19 | // COM, set the ComVisible attribute to true on that type.
20 | [assembly: ComVisible(false)]
21 | 
22 | // The following GUID is for the ID of the typelib if this project is exposed to COM
23 | [assembly: Guid("2ad4988e-c0cf-4730-bd12-5a1d590cad90")]
24 | 
25 | // Version information for an assembly consists of the following four values:
26 | //
27 | //      Major Version
28 | //      Minor Version
29 | //      Build Number
30 | //      Revision
31 | //
32 | // You can specify all the values or you can default the Build and Revision Numbers
33 | // by using the '*' as shown below:
34 | // [assembly: AssemblyVersion("1.0.*")]
35 | [assembly: AssemblyVersion("1.0.0.0")]
36 | [assembly: AssemblyFileVersion("1.0.0.0")]
37 | 


--------------------------------------------------------------------------------
/StrandardDeep Cheat/RaftESP.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Collections;
 4 | using UnityEngine;
 5 | using Beam;
 6 | using Beam.AI;
 7 | 
 8 | namespace StrandardDeep_Cheat
 9 | {
10 |     public class RaftESP : MonoBehaviour
11 |     {
12 |         private void Start()
13 |         {
14 | 
15 |         }
16 |         IEnumerator SleepFor(float Time)
17 |         {
18 |             yield return new WaitForSeconds(Time);
19 |         }
20 | 
21 |         Player localplayer = FindObjectsOfType<Player>()[0];
22 |         private void OnGUI()
23 |         {
24 |             if (Menu.LootESP == true)
25 |             {
26 |                 if (Menu.RaftESP)
27 |                 {
28 |                     IEnumerable<Interactive_RAFT_STORAGE> playerProxies = FindObjectsOfType<Interactive_RAFT_STORAGE>();
29 |                     foreach (Interactive_RAFT_STORAGE playerProxy in playerProxies)
30 |                     {
31 | 
32 |                         Vector3 pos = playerProxy.transform.position;
33 |                         Vector3 posScreen = Camera.main.WorldToScreenPoint(pos);
34 | 
35 |                         if (posScreen.z > 0 & posScreen.y < Screen.width - 2)
36 |                         {
37 |                             float dist = Vector3.Distance(pos, localplayer.transform.position);
38 |                             if (dist < Menu.LoopDist)
39 |                             {
40 |  
41 |                                 posScreen.y = Screen.height - (posScreen.y + 1f);
42 |                                 Render.DrawString(new Vector2(posScreen.x, posScreen.y), (" Raft" + string.Format(" [{0:0}m]", (object)dist)), Color.green);
43 |                             }
44 |                         }
45 |                         SleepFor(0.300f);
46 |                     }
47 |                     SleepFor(0.300f);
48 |                 }
49 |                 SleepFor(0.300f);
50 | 
51 |             }
52 |         }
53 | 
54 | 
55 |         private void Update()
56 |         {
57 | 
58 |         }
59 |     }
60 | }
61 | 


--------------------------------------------------------------------------------
/StrandardDeep Cheat/Render.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using UnityEngine;
 3 | 
 4 | namespace StrandardDeep_Cheat
 5 | {
 6 |     public static class Render
 7 |     {
 8 |         public static GUIStyle StringStyle { get; set; } = new GUIStyle(GUI.skin.label);
 9 | 
10 |         public static Color Color
11 |         {
12 |             get { return GUI.color; }
13 |             set { GUI.color = value; }
14 |         }
15 | 
16 |         public static void DrawLine(Vector2 from, Vector2 to, Color color)
17 |         {
18 |             Color = color;
19 |             DrawLine(from, to);
20 |         }
21 |         public static void DrawLine(Vector2 from, Vector2 to)
22 |         {
23 |             var angle = Vector2.Angle(from, to);
24 |             GUIUtility.RotateAroundPivot(angle, from);
25 |             DrawBox(from, Vector2.right * (from - to).magnitude, false);
26 |             GUIUtility.RotateAroundPivot(-angle, from);
27 |         }
28 | 
29 |         public static void DrawBox(Vector2 position, Vector2 size, Color color, bool centered = true)
30 |         {
31 |             Color = color;
32 |             DrawBox(position, size, centered);
33 |         }
34 |         public static void DrawBox(Vector2 position, Vector2 size, bool centered = true)
35 |         {
36 |             var upperLeft = centered ? position - size / 2f : position;
37 |             GUI.DrawTexture(new Rect(position, size), Texture2D.whiteTexture, ScaleMode.StretchToFill);
38 |         }
39 | 
40 |         public static void DrawString(Vector2 position, string label, Color color, bool centered = true)
41 |         {
42 |             Color = color;
43 |             DrawString(position, label, centered);
44 |         }
45 |         public static void DrawString(Vector2 position, string label, bool centered = true)
46 |         {
47 |             var content = new GUIContent(label);
48 |             var size = StringStyle.CalcSize(content);
49 |             var upperLeft = centered ? position - size / 2f : position;
50 |             GUI.Label(new Rect(upperLeft, size), content);
51 |         }
52 | 
53 |     }
54 | }
55 | 


--------------------------------------------------------------------------------
/StrandardDeep Cheat/ResourcesESP.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Collections;
 4 | using UnityEngine;
 5 | using Beam;
 6 | using Beam.AI;
 7 | 
 8 | namespace StrandardDeep_Cheat
 9 | {
10 |     public class ResourcesHARVESTPLANTESP : MonoBehaviour
11 |     {
12 |         private void Start()
13 |         {
14 | 
15 |         }
16 |         IEnumerator SleepFor(float Time)
17 |         {
18 |             yield return new WaitForSeconds(Time);
19 |         }
20 | 
21 |         Player localplayer = FindObjectsOfType<Player>()[0];
22 |         private void OnGUI()
23 |         {
24 |             if (Menu.LootESP == true)
25 |             {
26 |                 if (Menu.ResourcesESP)
27 |                 {
28 |                     IEnumerable<InteractiveObject_HARVESTPLANT> playerProxies = FindObjectsOfType<InteractiveObject_HARVESTPLANT>();
29 |                     foreach (InteractiveObject_HARVESTPLANT playerProxy in playerProxies)
30 |                     {
31 | 
32 |                         Vector3 pos = playerProxy.transform.position;
33 |                         Vector3 posScreen = Camera.main.WorldToScreenPoint(pos);
34 | 
35 |                         if (posScreen.z > 0 & posScreen.y < Screen.width - 2)
36 |                         {
37 |                             float dist = Vector3.Distance(pos, localplayer.transform.position);
38 |                             if (dist < Menu.LoopDist)
39 |                             {
40 |                                 posScreen.y = Screen.height - (posScreen.y + 1f);
41 |                                 Render.DrawString(new Vector2(posScreen.x, posScreen.y), ("  Harvest Plant" + string.Format(" [{0:0}m]", (object)dist)), Color.green);
42 |                             }
43 |                         }
44 |                         SleepFor(0.300f);
45 |                     }
46 |                     SleepFor(0.300f);
47 |                 }
48 |                 SleepFor(0.300f);
49 | 
50 |             }
51 |         }
52 | 
53 | 
54 |         private void Update()
55 |         {
56 | 
57 |         }
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/StrandardDeep Cheat/ResourcesESP1.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Collections;
 4 | using UnityEngine;
 5 | using Beam;
 6 | using Beam.AI;
 7 | 
 8 | namespace StrandardDeep_Cheat
 9 | {
10 |     public class ResourcesHARVESTRESOURCEESP : MonoBehaviour
11 |     {
12 |         private void Start()
13 |         {
14 | 
15 |         }
16 |         IEnumerator SleepFor(float Time)
17 |         {
18 |             yield return new WaitForSeconds(Time);
19 |         }
20 | 
21 |         Player localplayer = FindObjectsOfType<Player>()[0];
22 |         private void OnGUI()
23 |         {
24 |             if (Menu.LootESP == true)
25 |             {
26 |                 if (Menu.ResourcesESP)
27 |                 {
28 |                     IEnumerable<InteractiveObject_HARVESTRESOURCE> playerProxies = FindObjectsOfType<InteractiveObject_HARVESTRESOURCE>();
29 |                     foreach (InteractiveObject_HARVESTRESOURCE playerProxy in playerProxies)
30 |                     {
31 | 
32 |                         Vector3 pos = playerProxy.transform.position;
33 |                         Vector3 posScreen = Camera.main.WorldToScreenPoint(pos);
34 | 
35 |                         if (posScreen.z > 0 & posScreen.y < Screen.width - 2)
36 |                         {
37 |                             float dist = Vector3.Distance(pos, localplayer.transform.position);
38 |                             if (dist < Menu.LoopDist)
39 |                             {
40 |                                 posScreen.y = Screen.height - (posScreen.y + 1f);
41 |                                 Render.DrawString(new Vector2(posScreen.x, posScreen.y), ("  Harvest Source" + string.Format(" [{0:0}m]", (object)dist)), Color.green);
42 |                             }
43 |                         }
44 |                         SleepFor(0.300f);
45 |                     }
46 |                     SleepFor(0.300f);
47 |                 }
48 |                 SleepFor(0.300f);
49 | 
50 |             }
51 |         }
52 | 
53 | 
54 |         private void Update()
55 |         {
56 | 
57 |         }
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/StrandardDeep Cheat/ResourcesESP2.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Collections;
 4 | using UnityEngine;
 5 | using Beam;
 6 | using Beam.AI;
 7 | 
 8 | namespace StrandardDeep_Cheat
 9 | {
10 |     public class ResourcesPALM_LOGESP : MonoBehaviour
11 |     {
12 |         private void Start()
13 |         {
14 | 
15 |         }
16 |         IEnumerator SleepFor(float Time)
17 |         {
18 |             yield return new WaitForSeconds(Time);
19 |         }
20 | 
21 |         Player localplayer = FindObjectsOfType<Player>()[0];
22 |         private void OnGUI()
23 |         {
24 |             if (Menu.LootESP == true)
25 |             {
26 |                 if (Menu.ResourcesESP)
27 |                 {
28 |                     IEnumerable<InteractiveObject_PALM_LOG> playerProxies = FindObjectsOfType<InteractiveObject_PALM_LOG>();
29 |                     foreach (InteractiveObject_PALM_LOG playerProxy in playerProxies)
30 |                     {
31 | 
32 |                         Vector3 pos = playerProxy.transform.position;
33 |                         Vector3 posScreen = Camera.main.WorldToScreenPoint(pos);
34 | 
35 |                         if (posScreen.z > 0 & posScreen.y < Screen.width - 2)
36 |                         {
37 |                             float dist = Vector3.Distance(pos, localplayer.transform.position);
38 |                             if (dist < Menu.LoopDist)
39 |                             {
40 |                                 posScreen.y = Screen.height - (posScreen.y + 1f);
41 |                                 Render.DrawString(new Vector2(posScreen.x, posScreen.y), ("   Palm Logs" + string.Format(" [{0:0}m]", (object)dist)), Color.green);
42 |                             }
43 |                         }
44 |                         SleepFor(0.300f);
45 |                     }
46 |                     SleepFor(0.300f);
47 |                 }
48 |                 SleepFor(0.300f);
49 | 
50 |             }
51 |         }
52 | 
53 | 
54 |         private void Update()
55 |         {
56 | 
57 |         }
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/StrandardDeep Cheat/SharkESP.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Collections;
 4 | using UnityEngine;
 5 | using Beam;
 6 | using Beam.AI;
 7 | 
 8 | namespace StrandardDeep_Cheat
 9 | {
10 |     public class SharkESP : MonoBehaviour
11 |     {
12 |         private void Start()
13 |         {
14 | 
15 |         }
16 |         IEnumerator SleepFor(float Time)
17 |         {
18 |             yield return new WaitForSeconds(Time);
19 |         }
20 | 
21 |         Player localplayer = FindObjectsOfType<Player>()[0];
22 |         private void OnGUI()
23 |         {
24 |             if (Menu.EntityESP == true)
25 |             {
26 |                 if (Menu.sharkESP)
27 |                 {
28 |                     IEnumerable<InteractiveObject_PISCUS> playerProxies = FindObjectsOfType<InteractiveObject_PISCUS>();
29 |                     foreach (InteractiveObject_PISCUS playerProxy in playerProxies)
30 |                     {
31 |                         
32 |                         Vector3 pos = playerProxy.transform.position;
33 |                         Vector3 posScreen = Camera.main.WorldToScreenPoint(pos);
34 | 
35 |                         if (posScreen.z > 0 & posScreen.y < Screen.width - 2)
36 |                         {
37 |                             float dist = Vector3.Distance(pos, localplayer.transform.position);
38 |                             if (dist < Menu.EntityDist)
39 |                             {
40 |                                 posScreen.y = Screen.height - (posScreen.y + 1f);
41 |                                 Render.DrawString(new Vector2(posScreen.x, posScreen.y), ("  Shark" + string.Format(" [{0:0}m]", (object)dist)), Color.green);
42 |                             }
43 |                         }
44 |                         SleepFor(0.300f);
45 |                     }
46 |                     SleepFor(0.300f);
47 |                 }
48 |                 SleepFor(0.300f);
49 | 
50 |             }
51 |         }
52 | 
53 | 
54 |         private void Update()
55 |         {
56 | 
57 |         }
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/StrandardDeep Cheat/SkinnableESP.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Collections;
 4 | using UnityEngine;
 5 | using Beam;
 6 | using Beam.AI;
 7 | 
 8 | namespace StrandardDeep_Cheat
 9 | {
10 |     public class SkinnableESP : MonoBehaviour
11 |     {
12 |         private void Start()
13 |         {
14 | 
15 |         }
16 |         IEnumerator SleepFor(float Time)
17 |         {
18 |             yield return new WaitForSeconds(Time);
19 |         }
20 | 
21 |         Player localplayer = FindObjectsOfType<Player>()[0];
22 |         private void OnGUI()
23 |         {
24 |             if (Menu.EntityESP == true)
25 |             {
26 |                 if (Menu.SkinnableESP)
27 |                 {
28 |                     IEnumerable<Interactive_SKINNABLE> playerProxies = FindObjectsOfType<Interactive_SKINNABLE>();
29 |                     foreach (Interactive_SKINNABLE playerProxy in playerProxies)
30 |                     {
31 | 
32 |                         Vector3 pos = playerProxy.transform.position;
33 |                         Vector3 posScreen = Camera.main.WorldToScreenPoint(pos);
34 |                         if (posScreen.z > 0 & posScreen.y < Screen.width - 2)
35 |                         {
36 |                             
37 | 
38 | 
39 |                             float dist = Vector3.Distance(pos, localplayer.transform.position);
40 |                             if (dist < Menu.EntityDist)
41 |                             {
42 |                                 //Extremely useful
43 | 
44 |                                 //Interactive_FISHES proxyName = playerProxy.GetComponent<Interactive_FISHES>();
45 | 
46 |                                 posScreen.y = Screen.height - (posScreen.y + 1f);
47 |                                 Render.DrawString(new Vector2(posScreen.x, posScreen.y), ("   Skinnable" + string.Format(" [{0:0}m]", (object)dist)), Color.green);
48 |                             }
49 |                         }
50 |                         SleepFor(0.300f);
51 |                     }
52 |                     SleepFor(0.300f);
53 |                 }
54 |                 SleepFor(0.300f);
55 | 
56 |             }
57 |         }
58 | 
59 | 
60 |         private void Update()
61 |         {
62 | 
63 |         }
64 |     }
65 | }
66 | 


--------------------------------------------------------------------------------
/StrandardDeep Cheat/StrandardDeep Cheat.csproj:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="utf-8"?>
  2 | <Project ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  3 |   <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
  4 |   <PropertyGroup>
  5 |     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
  6 |     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
  7 |     <ProjectGuid>{2AD4988E-C0CF-4730-BD12-5A1D590CAD90}</ProjectGuid>
  8 |     <OutputType>Library</OutputType>
  9 |     <AppDesignerFolder>Properties</AppDesignerFolder>
 10 |     <RootNamespace>StrandardDeep_Cheat</RootNamespace>
 11 |     <AssemblyName>StrandardDeep Cheat</AssemblyName>
 12 |     <TargetFrameworkVersion>v4.6.1</TargetFrameworkVersion>
 13 |     <FileAlignment>512</FileAlignment>
 14 |   </PropertyGroup>
 15 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
 16 |     <DebugSymbols>true</DebugSymbols>
 17 |     <DebugType>full</DebugType>
 18 |     <Optimize>false</Optimize>
 19 |     <OutputPath>bin\Debug\</OutputPath>
 20 |     <DefineConstants>DEBUG;TRACE</DefineConstants>
 21 |     <ErrorReport>prompt</ErrorReport>
 22 |     <WarningLevel>4</WarningLevel>
 23 |   </PropertyGroup>
 24 |   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
 25 |     <DebugType>pdbonly</DebugType>
 26 |     <Optimize>true</Optimize>
 27 |     <OutputPath>bin\Release\</OutputPath>
 28 |     <DefineConstants>TRACE</DefineConstants>
 29 |     <ErrorReport>prompt</ErrorReport>
 30 |     <WarningLevel>4</WarningLevel>
 31 |   </PropertyGroup>
 32 |   <ItemGroup>
 33 |     <Compile Include="BirdsESP.cs" />
 34 |     <Compile Include="FishesESP.cs" />
 35 |     <Compile Include="FoodESP.cs" />
 36 |     <Compile Include="FuelCanESP.cs" />
 37 |     <Compile Include="Loader.cs" />
 38 |     <Compile Include="CrabESP.cs" />
 39 |     <Compile Include="Main.cs" />
 40 |     <Compile Include="Menu.cs" />
 41 |     <Compile Include="MiningRocksESP.cs" />
 42 |     <Compile Include="MissionBoardsESP.cs" />
 43 |     <Compile Include="Properties\AssemblyInfo.cs" />
 44 |     <Compile Include="RaftESP.cs" />
 45 |     <Compile Include="Render.cs" />
 46 |     <Compile Include="ResourcesESP.cs" />
 47 |     <Compile Include="ResourcesESP1.cs" />
 48 |     <Compile Include="ResourcesESP2.cs" />
 49 |     <Compile Include="SharkESP.cs" />
 50 |     <Compile Include="SkinnableESP.cs" />
 51 |     <Compile Include="WhaleESP.cs" />
 52 |   </ItemGroup>
 53 |   <ItemGroup>
 54 |     <Reference Include="Assembly-CSharp">
 55 |       <HintPath>D:\SteamLibrary\steamapps\common\Stranded Deep\Stranded_Deep_Data\Managed\Assembly-CSharp.dll</HintPath>
 56 |     </Reference>
 57 |     <Reference Include="Assembly-CSharp-firstpass">
 58 |       <HintPath>D:\SteamLibrary\steamapps\common\Stranded Deep\Stranded_Deep_Data\Managed\Assembly-CSharp-firstpass.dll</HintPath>
 59 |     </Reference>
 60 |     <Reference Include="AsyncBridge.Net35">
 61 |       <HintPath>D:\SteamLibrary\steamapps\common\Stranded Deep\Stranded_Deep_Data\Managed\AsyncBridge.Net35.dll</HintPath>
 62 |     </Reference>
 63 |     <Reference Include="ch.sycoforge.Decal">
 64 |       <HintPath>D:\SteamLibrary\steamapps\common\Stranded Deep\Stranded_Deep_Data\Managed\ch.sycoforge.Decal.dll</HintPath>
 65 |     </Reference>
 66 |     <Reference Include="Mono.Security">
 67 |       <HintPath>D:\SteamLibrary\steamapps\common\Stranded Deep\Stranded_Deep_Data\Managed\Mono.Security.dll</HintPath>
 68 |     </Reference>
 69 |     <Reference Include="Newtonsoft.Json, Version=6.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
 70 |       <SpecificVersion>False</SpecificVersion>
 71 |       <HintPath>D:\SteamLibrary\steamapps\common\Stranded Deep\Stranded_Deep_Data\Managed\Newtonsoft.Json.dll</HintPath>
 72 |     </Reference>
 73 |     <Reference Include="Rewired_Core">
 74 |       <HintPath>D:\SteamLibrary\steamapps\common\Stranded Deep\Stranded_Deep_Data\Managed\Rewired_Core.dll</HintPath>
 75 |     </Reference>
 76 |     <Reference Include="Rewired_Windows_Lib">
 77 |       <HintPath>D:\SteamLibrary\steamapps\common\Stranded Deep\Stranded_Deep_Data\Managed\Rewired_Windows_Lib.dll</HintPath>
 78 |     </Reference>
 79 |     <Reference Include="Sirenix.OdinInspector.Attributes">
 80 |       <HintPath>D:\SteamLibrary\steamapps\common\Stranded Deep\Stranded_Deep_Data\Managed\Sirenix.OdinInspector.Attributes.dll</HintPath>
 81 |     </Reference>
 82 |     <Reference Include="Sirenix.Serialization">
 83 |       <HintPath>D:\SteamLibrary\steamapps\common\Stranded Deep\Stranded_Deep_Data\Managed\Sirenix.Serialization.dll</HintPath>
 84 |     </Reference>
 85 |     <Reference Include="Sirenix.Serialization.Config">
 86 |       <HintPath>D:\SteamLibrary\steamapps\common\Stranded Deep\Stranded_Deep_Data\Managed\Sirenix.Serialization.Config.dll</HintPath>
 87 |     </Reference>
 88 |     <Reference Include="Sirenix.Utilities">
 89 |       <HintPath>D:\SteamLibrary\steamapps\common\Stranded Deep\Stranded_Deep_Data\Managed\Sirenix.Utilities.dll</HintPath>
 90 |     </Reference>
 91 |     <Reference Include="System" />
 92 |     <Reference Include="System.Threading">
 93 |       <HintPath>D:\SteamLibrary\steamapps\common\Stranded Deep\Stranded_Deep_Data\Managed\System.Threading.dll</HintPath>
 94 |     </Reference>
 95 |     <Reference Include="System.Xml" />
 96 |     <Reference Include="System.Xml.Linq" />
 97 |     <Reference Include="UnityEngine">
 98 |       <HintPath>D:\SteamLibrary\steamapps\common\Stranded Deep\Stranded_Deep_Data\Managed\UnityEngine.dll</HintPath>
 99 |     </Reference>
100 |     <Reference Include="UnityEngine.Networking">
101 |       <HintPath>D:\SteamLibrary\steamapps\common\Stranded Deep\Stranded_Deep_Data\Managed\UnityEngine.Networking.dll</HintPath>
102 |     </Reference>
103 |     <Reference Include="UnityEngine.UI">
104 |       <HintPath>D:\SteamLibrary\steamapps\common\Stranded Deep\Stranded_Deep_Data\Managed\UnityEngine.UI.dll</HintPath>
105 |     </Reference>
106 |   </ItemGroup>
107 |   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
108 | </Project>


--------------------------------------------------------------------------------
/StrandardDeep Cheat/WhaleESP.cs:
--------------------------------------------------------------------------------
 1 | using System;
 2 | using System.Collections.Generic;
 3 | using System.Collections;
 4 | using UnityEngine;
 5 | using Beam;
 6 | using Beam.AI;
 7 | 
 8 | namespace StrandardDeep_Cheat
 9 | {
10 |     public class WhaleESP : MonoBehaviour
11 |     {
12 |         private void Start()
13 |         {
14 | 
15 |         }
16 |         IEnumerator SleepFor(float Time)
17 |         {
18 |             yield return new WaitForSeconds(Time);
19 |         }
20 | 
21 |         Player localplayer = FindObjectsOfType<Player>()[0];
22 |         private void OnGUI()
23 |         {
24 |             if (Menu.EntityESP == true)
25 |             {
26 |                 if (Menu.SkinnableESP)
27 |                 {
28 |                     IEnumerable<InteractiveObject_WHALE> playerProxies = FindObjectsOfType<InteractiveObject_WHALE>();
29 |                     foreach (InteractiveObject_WHALE playerProxy in playerProxies)
30 |                     {
31 | 
32 |                         Vector3 pos = playerProxy.transform.position;
33 |                         Vector3 posScreen = Camera.main.WorldToScreenPoint(pos);
34 | 
35 |                         if (posScreen.z > 0 & posScreen.y < Screen.width - 2)
36 |                         {
37 |                             float dist = Vector3.Distance(pos, localplayer.transform.position);
38 |                             if (dist < Menu.EntityDist)
39 |                             {
40 |                                 posScreen.y = Screen.height - (posScreen.y + 1f);
41 |                                 Render.DrawString(new Vector2(posScreen.x, posScreen.y), ("   Whale" + string.Format(" [{0:0}m]", (object)dist)), Color.green);
42 |                             }
43 |                         }
44 |                         SleepFor(0.300f);
45 |                     }
46 |                     SleepFor(0.300f);
47 |                 }
48 |                 SleepFor(0.300f);
49 | 
50 |             }
51 |         }
52 | 
53 | 
54 |         private void Update()
55 |         {
56 | 
57 |         }
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------