├── .gitignore
├── CHANGELOG.md
├── Concealment.Tests
├── Concealment.Tests.csproj
├── Properties
│ └── AssemblyInfo.cs
├── ReflectionTestManager.cs
├── TestUtils.cs
├── TorchReflectionTest.cs
└── packages.config
├── Concealment.sln
├── Concealment
├── Commands.cs
├── ConcealGroup.cs
├── Concealment.csproj
├── ConcealmentControl.xaml
├── ConcealmentControl.xaml.cs
├── ConcealmentPlugin.cs
├── DynamicConcealmentEditor.xaml
├── DynamicConcealmentEditor.xaml.cs
├── DynamicConcealmentManager.cs
├── Properties
│ └── AssemblyInfo.cs
├── Settings.cs
└── packages.config
├── Jenkins
├── PluginPush.exe
├── jenkins-grab-se.ps1
└── release.ps1
├── Jenkinsfile
├── README.md
├── Setup (run before opening solution).bat
├── Versioning
├── AssemblyVersion.cs
└── version.ps1
└── manifest.xml
/.gitignore:
--------------------------------------------------------------------------------
1 | ## Ignore Visual Studio temporary files, build results, and
2 | ## files generated by popular Visual Studio add-ons.
3 |
4 | # User-specific files
5 | *.suo
6 | *.user
7 | *.userosscache
8 | *.sln.docstates
9 |
10 | # User-specific files (MonoDevelop/Xamarin Studio)
11 | *.userprefs
12 |
13 | # Build results
14 | [Dd]ebug/
15 | [Dd]ebugPublic/
16 | [Rr]elease/
17 | [Rr]eleases/
18 | x64/
19 | x86/
20 | bld/
21 | [Bb]in/
22 | [Oo]bj/
23 | [Ll]og/
24 |
25 | # Visual Studio 2015 cache/options directory
26 | .vs/
27 | # Uncomment if you have tasks that create the project's static files in wwwroot
28 | #wwwroot/
29 |
30 | # MSTest test Results
31 | [Tt]est[Rr]esult*/
32 | [Bb]uild[Ll]og.*
33 |
34 | # NUNIT
35 | *.VisualState.xml
36 | TestResult.xml
37 |
38 | # Build Results of an ATL Project
39 | [Dd]ebugPS/
40 | [Rr]eleasePS/
41 | dlldata.c
42 |
43 | # DNX
44 | project.lock.json
45 | artifacts/
46 |
47 | *_i.c
48 | *_p.c
49 | *_i.h
50 | *.ilk
51 | *.meta
52 | *.obj
53 | *.pch
54 | *.pdb
55 | *.pgc
56 | *.pgd
57 | *.rsp
58 | *.sbr
59 | *.tlb
60 | *.tli
61 | *.tlh
62 | *.tmp
63 | *.tmp_proj
64 | *.log
65 | *.vspscc
66 | *.vssscc
67 | .builds
68 | *.pidb
69 | *.svclog
70 | *.scc
71 |
72 | # Chutzpah Test files
73 | _Chutzpah*
74 |
75 | # Visual C++ cache files
76 | ipch/
77 | *.aps
78 | *.ncb
79 | *.opendb
80 | *.opensdf
81 | *.sdf
82 | *.cachefile
83 | *.VC.db
84 | *.VC.VC.opendb
85 |
86 | # Visual Studio profiler
87 | *.psess
88 | *.vsp
89 | *.vspx
90 | *.sap
91 |
92 | # TFS 2012 Local Workspace
93 | $tf/
94 |
95 | # Guidance Automation Toolkit
96 | *.gpState
97 |
98 | # ReSharper is a .NET coding add-in
99 | _ReSharper*/
100 | *.[Rr]e[Ss]harper
101 | *.DotSettings.user
102 |
103 | # JustCode is a .NET coding add-in
104 | .JustCode
105 |
106 | # TeamCity is a build add-in
107 | _TeamCity*
108 |
109 | # DotCover is a Code Coverage Tool
110 | *.dotCover
111 |
112 | # NCrunch
113 | _NCrunch_*
114 | .*crunch*.local.xml
115 | nCrunchTemp_*
116 |
117 | # MightyMoose
118 | *.mm.*
119 | AutoTest.Net/
120 |
121 | # Web workbench (sass)
122 | .sass-cache/
123 |
124 | # Installshield output folder
125 | [Ee]xpress/
126 |
127 | # DocProject is a documentation generator add-in
128 | DocProject/buildhelp/
129 | DocProject/Help/*.HxT
130 | DocProject/Help/*.HxC
131 | DocProject/Help/*.hhc
132 | DocProject/Help/*.hhk
133 | DocProject/Help/*.hhp
134 | DocProject/Help/Html2
135 | DocProject/Help/html
136 |
137 | # Click-Once directory
138 | publish/
139 |
140 | # Publish Web Output
141 | *.[Pp]ublish.xml
142 | *.azurePubxml
143 | # TODO: Comment the next line if you want to checkin your web deploy settings
144 | # but database connection strings (with potential passwords) will be unencrypted
145 | *.pubxml
146 | *.publishproj
147 |
148 | # Microsoft Azure Web App publish settings. Comment the next line if you want to
149 | # checkin your Azure Web App publish settings, but sensitive information contained
150 | # in these scripts will be unencrypted
151 | PublishScripts/
152 |
153 | # NuGet Packages
154 | *.nupkg
155 | # The packages folder can be ignored because of Package Restore
156 | **/packages/*
157 | # except build/, which is used as an MSBuild target.
158 | !**/packages/build/
159 | # Uncomment if necessary however generally it will be regenerated when needed
160 | #!**/packages/repositories.config
161 | # NuGet v3's project.json files produces more ignoreable files
162 | *.nuget.props
163 | *.nuget.targets
164 |
165 | # Microsoft Azure Build Output
166 | csx/
167 | *.build.csdef
168 |
169 | # Microsoft Azure Emulator
170 | ecf/
171 | rcf/
172 |
173 | # Windows Store app package directories and files
174 | AppPackages/
175 | BundleArtifacts/
176 | Package.StoreAssociation.xml
177 | _pkginfo.txt
178 |
179 | # Visual Studio cache files
180 | # files ending in .cache can be ignored
181 | *.[Cc]ache
182 | # but keep track of directories ending in .cache
183 | !*.[Cc]ache/
184 |
185 | # Others
186 | ClientBin/
187 | ~$*
188 | *~
189 | *.dbmdl
190 | *.dbproj.schemaview
191 | *.pfx
192 | *.publishsettings
193 | node_modules/
194 | orleans.codegen.cs
195 |
196 | # Since there are multiple workflows, uncomment next line to ignore bower_components
197 | # (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
198 | #bower_components/
199 |
200 | # RIA/Silverlight projects
201 | Generated_Code/
202 |
203 | # Backup & report files from converting an old project file
204 | # to a newer Visual Studio version. Backup files are not needed,
205 | # because we have git ;-)
206 | _UpgradeReport_Files/
207 | Backup*/
208 | UpgradeLog*.XML
209 | UpgradeLog*.htm
210 |
211 | # SQL Server files
212 | *.mdf
213 | *.ldf
214 |
215 | # Business Intelligence projects
216 | *.rdl.data
217 | *.bim.layout
218 | *.bim_*.settings
219 |
220 | # Microsoft Fakes
221 | FakesAssemblies/
222 |
223 | # GhostDoc plugin setting file
224 | *.GhostDoc.xml
225 |
226 | # Node.js Tools for Visual Studio
227 | .ntvs_analysis.dat
228 |
229 | # Visual Studio 6 build log
230 | *.plg
231 |
232 | # Visual Studio 6 workspace options file
233 | *.opt
234 |
235 | # Visual Studio LightSwitch build output
236 | **/*.HTMLClient/GeneratedArtifacts
237 | **/*.DesktopClient/GeneratedArtifacts
238 | **/*.DesktopClient/ModelManifest.xml
239 | **/*.Server/GeneratedArtifacts
240 | **/*.Server/ModelManifest.xml
241 | _Pvt_Extensions
242 |
243 | # Paket dependency manager
244 | .paket/paket.exe
245 | paket-files/
246 |
247 | # FAKE - F# Make
248 | .fake/
249 |
250 | # JetBrains Rider
251 | .idea/
252 | *.sln.iml
253 |
254 | GameBinaries
255 | TorchBinaries
--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
1 | # Concealment 1.2.1
2 | * Fixes
3 | - Fixed off-by-one crash in RevealGrids()
4 |
5 | # Concealment 1.2
6 | * Features
7 | - Added option to exempt pirate-owned grids
8 | - Added action to RC block so scripts can keep active drones from being concealed
9 | - Added commands to enable and disable concealment
10 | * Fixes
11 | - Fixed crashes when deleting concealed entities
--------------------------------------------------------------------------------
/Concealment.Tests/Concealment.Tests.csproj:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | {53EFDFD0-9BCA-4E67-ABB2-628715E3F74B}
6 | Library
7 | Properties
8 | Concealment.Tests
9 | Concealment.Tests
10 | v4.6.1
11 | 512
12 |
13 |
14 |
15 | 1591,0649
16 |
17 |
18 | true
19 | $(SolutionDir)\bin-test\x64\Debug\
20 | DEBUG;TRACE
21 | full
22 | x64
23 | prompt
24 | MinimumRecommendedRules.ruleset
25 |
26 |
27 | $(SolutionDir)\bin-test\x64\Release\
28 | TRACE
29 | true
30 | pdbonly
31 | x64
32 | prompt
33 | MinimumRecommendedRules.ruleset
34 | $(SolutionDir)\bin-test\x64\Release\Concealment.Tests.xml
35 |
36 |
37 |
38 | ..\packages\NLog.4.4.12\lib\net45\NLog.dll
39 | True
40 |
41 |
42 |
43 |
44 |
45 |
46 |
47 |
48 |
49 |
50 | ..\packages\xunit.abstractions.2.0.1\lib\net35\xunit.abstractions.dll
51 |
52 |
53 | ..\packages\xunit.assert.2.2.0\lib\netstandard1.1\xunit.assert.dll
54 |
55 |
56 | ..\packages\xunit.extensibility.core.2.2.0\lib\netstandard1.1\xunit.core.dll
57 |
58 |
59 | ..\packages\xunit.extensibility.execution.2.2.0\lib\net452\xunit.execution.desktop.dll
60 |
61 |
62 | $(SolutionDir)\TorchBinaries\Torch.dll
63 | True
64 |
65 |
66 | $(SolutionDir)\TorchBinaries\Torch.API.dll
67 | True
68 |
69 |
70 |
71 |
72 | Properties\AssemblyVersion.cs
73 |
74 |
75 |
76 |
77 |
78 |
79 |
80 |
81 | {E5C0184B-7DC4-43D8-872E-2F71162748AA}
82 | Concealment
83 | True
84 |
85 |
86 |
87 |
88 |
89 |
90 |
91 |
92 |
93 |
--------------------------------------------------------------------------------
/Concealment.Tests/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
1 | using System.Reflection;
2 | using System.Runtime.InteropServices;
3 |
4 | [assembly: AssemblyTitle("Torch Tests")]
5 | [assembly: AssemblyDescription("")]
6 | [assembly: AssemblyCompany("")]
7 | [assembly: AssemblyProduct("Torch")]
8 | [assembly: AssemblyCopyright("Copyright © Torch API 2017")]
9 | [assembly: AssemblyTrademark("")]
10 | [assembly: AssemblyCulture("")]
11 | [assembly: ComVisible(false)]
12 |
13 | #if DEBUG
14 | [assembly: AssemblyConfiguration("Debug")]
15 | #else
16 | [assembly: AssemblyConfiguration("Release")]
17 | #endif
--------------------------------------------------------------------------------
/Concealment.Tests/ReflectionTestManager.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Reflection;
4 | using Torch.Utils;
5 |
6 | namespace Torch.Tests
7 | {
8 | public class ReflectionTestManager
9 | {
10 | #region FieldProvider
11 | public struct FieldRef
12 | {
13 | public FieldInfo Field;
14 |
15 | public FieldRef(FieldInfo f)
16 | {
17 | Field = f;
18 | }
19 |
20 | public override string ToString()
21 | {
22 | if (Field == null)
23 | return "Ignored";
24 | return Field.DeclaringType?.FullName + "." + Field.Name;
25 | }
26 | }
27 |
28 | private readonly HashSet _getters = new HashSet();
29 | private readonly HashSet _setters = new HashSet();
30 | private readonly HashSet _invokers = new HashSet();
31 |
32 | public ReflectionTestManager()
33 | {
34 | _getters.Add(new object[] { new FieldRef(null) });
35 | _setters.Add(new object[] { new FieldRef(null) });
36 | _invokers.Add(new object[] { new FieldRef(null) });
37 | }
38 |
39 | public ReflectionTestManager Init(Assembly asm)
40 | {
41 | foreach (Type type in asm.GetTypes())
42 | Init(type);
43 | return this;
44 | }
45 |
46 | public ReflectionTestManager Init(Type type)
47 | {
48 | foreach (FieldInfo field in type.GetFields(BindingFlags.Static |
49 | BindingFlags.Instance |
50 | BindingFlags.Public |
51 | BindingFlags.NonPublic))
52 | {
53 | if (field.GetCustomAttribute() != null)
54 | _invokers.Add(new object[] { new FieldRef(field) });
55 | if (field.GetCustomAttribute() != null)
56 | _getters.Add(new object[] { new FieldRef(field) });
57 | if (field.GetCustomAttribute() != null)
58 | _setters.Add(new object[] { new FieldRef(field) });
59 | }
60 | return this;
61 | }
62 |
63 | public IEnumerable Getters => _getters;
64 |
65 | public IEnumerable Setters => _setters;
66 |
67 | public IEnumerable Invokers => _invokers;
68 |
69 | #endregion
70 |
71 | }
72 | }
73 |
--------------------------------------------------------------------------------
/Concealment.Tests/TestUtils.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.IO;
4 | using System.Linq;
5 | using System.Text;
6 | using System.Threading.Tasks;
7 | using Torch.Utils;
8 |
9 | namespace Torch.Tests
10 | {
11 | public sealed class TestUtils
12 | {
13 | public static void Init()
14 | {
15 | if (_torchResolver == null)
16 | _torchResolver = new TorchAssemblyResolver(GetGameBinaries());
17 | }
18 |
19 | private static string GetGameBinaries()
20 | {
21 | string dir = Environment.CurrentDirectory;
22 | while (!string.IsNullOrWhiteSpace(dir))
23 | {
24 | string gameBin = Path.Combine(dir, "GameBinaries");
25 | if (Directory.Exists(gameBin))
26 | return gameBin;
27 |
28 | dir = Path.GetDirectoryName(dir);
29 | }
30 | throw new Exception("GetGameBinaries failed to find a folder named GameBinaries in the directory tree");
31 | }
32 |
33 | private static TorchAssemblyResolver _torchResolver;
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/Concealment.Tests/TorchReflectionTest.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.IO;
4 | using System.Linq;
5 | using System.Reflection;
6 | using System.Runtime.CompilerServices;
7 | using System.Runtime.InteropServices;
8 | using Torch.Tests;
9 | using Torch.Utils;
10 | using Xunit;
11 |
12 | namespace Concealment.Tests
13 | {
14 | public class TorchReflectionTest
15 | {
16 | static TorchReflectionTest()
17 | {
18 | TestUtils.Init();
19 | }
20 |
21 | private static ReflectionTestManager _manager;
22 |
23 | private static ReflectionTestManager Manager()
24 | {
25 | TestUtils.Init();
26 | if (_manager != null)
27 | return _manager;
28 | return _manager = new ReflectionTestManager().Init(typeof(ConcealmentPlugin).Assembly);
29 | }
30 |
31 | public static IEnumerable Getters => Manager().Getters;
32 |
33 | public static IEnumerable Setters => Manager().Setters;
34 |
35 | public static IEnumerable Invokers => Manager().Invokers;
36 |
37 | #region Binding
38 | [Theory]
39 | [MemberData(nameof(Getters))]
40 | public void TestBindingGetter(ReflectionTestManager.FieldRef field)
41 | {
42 | if (field.Field == null)
43 | return;
44 | Assert.True(ReflectedManager.Process(field.Field));
45 | if (field.Field.IsStatic)
46 | Assert.NotNull(field.Field.GetValue(null));
47 | }
48 |
49 | [Theory]
50 | [MemberData(nameof(Setters))]
51 | public void TestBindingSetter(ReflectionTestManager.FieldRef field)
52 | {
53 | if (field.Field == null)
54 | return;
55 | Assert.True(ReflectedManager.Process(field.Field));
56 | if (field.Field.IsStatic)
57 | Assert.NotNull(field.Field.GetValue(null));
58 | }
59 |
60 | [Theory]
61 | [MemberData(nameof(Invokers))]
62 | public void TestBindingInvoker(ReflectionTestManager.FieldRef field)
63 | {
64 | if (field.Field == null)
65 | return;
66 | Assert.True(ReflectedManager.Process(field.Field));
67 | if (field.Field.IsStatic)
68 | Assert.NotNull(field.Field.GetValue(null));
69 | }
70 | #endregion
71 | }
72 | }
73 |
--------------------------------------------------------------------------------
/Concealment.Tests/packages.config:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
--------------------------------------------------------------------------------
/Concealment.sln:
--------------------------------------------------------------------------------
1 |
2 | Microsoft Visual Studio Solution File, Format Version 12.00
3 | # Visual Studio 15
4 | VisualStudioVersion = 15.0.26730.15
5 | MinimumVisualStudioVersion = 10.0.40219.1
6 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Concealment", "Concealment\Concealment.csproj", "{E5C0184B-7DC4-43D8-872E-2F71162748AA}"
7 | EndProject
8 | Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Versioning", "Versioning", "{57BAE926-D9EB-40F2-AC36-007A1E2ED296}"
9 | ProjectSection(SolutionItems) = preProject
10 | Versioning\AssemblyVersion.cs = Versioning\AssemblyVersion.cs
11 | EndProjectSection
12 | EndProject
13 | Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Concealment.Tests", "Concealment.Tests\Concealment.Tests.csproj", "{53EFDFD0-9BCA-4E67-ABB2-628715E3F74B}"
14 | EndProject
15 | Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{C6C2FDC8-9D1B-4A13-B586-7DAD7F9BE7BB}"
16 | ProjectSection(SolutionItems) = preProject
17 | manifest.xml = manifest.xml
18 | EndProjectSection
19 | EndProject
20 | Global
21 | GlobalSection(SolutionConfigurationPlatforms) = preSolution
22 | Debug|x64 = Debug|x64
23 | Release|x64 = Release|x64
24 | EndGlobalSection
25 | GlobalSection(ProjectConfigurationPlatforms) = postSolution
26 | {E5C0184B-7DC4-43D8-872E-2F71162748AA}.Debug|x64.ActiveCfg = Debug|x64
27 | {E5C0184B-7DC4-43D8-872E-2F71162748AA}.Debug|x64.Build.0 = Debug|x64
28 | {E5C0184B-7DC4-43D8-872E-2F71162748AA}.Release|x64.ActiveCfg = Release|x64
29 | {E5C0184B-7DC4-43D8-872E-2F71162748AA}.Release|x64.Build.0 = Release|x64
30 | {53EFDFD0-9BCA-4E67-ABB2-628715E3F74B}.Debug|x64.ActiveCfg = Debug|x64
31 | {53EFDFD0-9BCA-4E67-ABB2-628715E3F74B}.Debug|x64.Build.0 = Debug|x64
32 | {53EFDFD0-9BCA-4E67-ABB2-628715E3F74B}.Release|x64.ActiveCfg = Release|x64
33 | {53EFDFD0-9BCA-4E67-ABB2-628715E3F74B}.Release|x64.Build.0 = Release|x64
34 | EndGlobalSection
35 | GlobalSection(SolutionProperties) = preSolution
36 | HideSolutionNode = FALSE
37 | EndGlobalSection
38 | GlobalSection(ExtensibilityGlobals) = postSolution
39 | SolutionGuid = {E12ECB82-E5CA-4599-B2D4-FE455DC8ED54}
40 | EndGlobalSection
41 | EndGlobal
42 |
--------------------------------------------------------------------------------
/Concealment/Commands.cs:
--------------------------------------------------------------------------------
1 | using Torch.Commands;
2 | using Torch.Commands.Permissions;
3 | using VRage.Game.ModAPI;
4 | using VRageMath;
5 |
6 | namespace Concealment
7 | {
8 | public class Commands : CommandModule
9 | {
10 | public ConcealmentPlugin Plugin => (ConcealmentPlugin)Context.Plugin;
11 |
12 | [Command("conceal", "Conceal grids x distance from players."), Permission(MyPromoteLevel.SpaceMaster)]
13 | public void Conceal(double distance = 0)
14 | {
15 | if (distance == 0)
16 | {
17 | distance = Plugin.Settings.Data.ConcealDistance;
18 | }
19 | var num = Plugin.ConcealGrids(distance);
20 | Context.Respond($"{num} grids concealed.");
21 | }
22 |
23 | [Command("reveal", "Reveal all grids within the given distance"), Permission(MyPromoteLevel.SpaceMaster)]
24 | public void Reveal(double distance = 1000)
25 | {
26 | var pos = Context.Player?.Controller.ControlledEntity?.Entity.GetPosition();
27 | if (!pos.HasValue)
28 | {
29 | Context.Respond("You must be controlling an entity.");
30 | return;
31 | }
32 |
33 | var sphere = new BoundingSphereD(pos.Value, distance);
34 | var num = Plugin.RevealGridsInSphere(sphere);
35 | Context.Respond($"{num} grids revealed.");
36 | }
37 |
38 | [Command("reveal all", "Reveal all grids"), Permission(MyPromoteLevel.SpaceMaster)]
39 | public void RevealAll()
40 | {
41 | int num = Plugin.RevealAll();
42 | Context.Respond($"{num} grids revealed.");
43 | }
44 |
45 | [Command("conceal on", "Enable concealment.")]
46 | public void Enable()
47 | {
48 | Plugin.Settings.Data.Enabled = true;
49 | Plugin.ConcealGrids(Plugin.Settings.Data.ConcealDistance);
50 | }
51 |
52 | [Command("conceal off", "Disable concealment.")]
53 | public void Disable()
54 | {
55 | Plugin.Settings.Data.Enabled = false;
56 | Plugin.RevealAll();
57 | }
58 | }
59 | }
--------------------------------------------------------------------------------
/Concealment/ConcealGroup.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using System.Reflection;
5 | using Havok;
6 | using NLog;
7 | using Sandbox.Engine.Physics;
8 | using Sandbox.Game.Entities;
9 | using Sandbox.Game.Entities.Blocks;
10 | using Sandbox.Game.World;
11 | using SpaceEngineers.Game.Entities.Blocks;
12 | using VRage.Audio;
13 | using VRage.Game.Entity;
14 | using VRage.Game.Entity.EntityComponents.Interfaces;
15 | using VRage.Groups;
16 | using VRage.ModAPI;
17 | using VRageMath;
18 |
19 | namespace Concealment
20 | {
21 | public class ConcealGroup
22 | {
23 | private static readonly Logger _log = LogManager.GetCurrentClassLogger();
24 | ///
25 | /// Entity ID of the first grid in the group.
26 | ///
27 | public long Id { get; }
28 | public bool IsConcealed { get; private set; }
29 | public BoundingBoxD WorldAABB { get; private set; }
30 | public List Grids { get; }
31 | public List MedicalRooms { get; } = new List();
32 | public List CryoChambers { get; } = new List();
33 | //private Dictionary _unstatic = new Dictionary();
34 | public event Action Closing;
35 | internal volatile int ProxyId = -1;
36 |
37 | public ConcealGroup(MyGroups.Group group)
38 | {
39 | Grids = group.Nodes.Select(n => n.NodeData).ToList();
40 | Id = Grids.First().EntityId;
41 | }
42 |
43 | public string GridNames
44 | {
45 | get { return string.Join(", ", Grids.Select(g => g.DisplayName)); }
46 | set { }
47 | }
48 |
49 | public void UpdatePostConceal()
50 | {
51 | IsConcealed = true;
52 | UpdateAABB();
53 | CacheSpawns();
54 | HookOnClosing();
55 | }
56 |
57 | public void UpdatePostReveal()
58 | {
59 | IsConcealed = false;
60 | UnhookOnClosing();
61 | }
62 |
63 | private void HookOnClosing()
64 | {
65 | foreach (var grid in Grids)
66 | grid.OnMarkForClose += Grid_OnMarkForClose;
67 | }
68 |
69 | private void UnhookOnClosing()
70 | {
71 | foreach (var grid in Grids)
72 | grid.OnMarkForClose -= Grid_OnMarkForClose;
73 | }
74 |
75 | private void Grid_OnMarkForClose(MyEntity obj)
76 | {
77 | _log.Debug($"Grid group '{GridNames}' was marked for close.");
78 | EnableProjectors();
79 | UnhookOnClosing();
80 | Closing?.Invoke(this);
81 | }
82 |
83 | public void UpdateAABB()
84 | {
85 | var startPos = Grids.First().PositionComp.GetPosition();
86 | var box = new BoundingBoxD(startPos, startPos);
87 |
88 | foreach (var aabb in Grids.Select(g => g.PositionComp.WorldAABB))
89 | box.Include(aabb);
90 |
91 | WorldAABB = box;
92 | }
93 |
94 | private void CacheSpawns()
95 | {
96 | MedicalRooms.Clear();
97 | CryoChambers.Clear();
98 |
99 | foreach (var block in Grids.SelectMany(x => x.GetFatBlocks()))
100 | {
101 | if (block is MyMedicalRoom medical)
102 | MedicalRooms.Add(medical);
103 | else if (block is MyCryoChamber cryo)
104 | CryoChambers.Add(cryo);
105 | }
106 | }
107 |
108 | public bool IsMedicalRoomAvailable(long identityId)
109 | {
110 | foreach (var room in MedicalRooms)
111 | {
112 | if (room.HasPlayerAccess(identityId) && room.IsWorking)
113 | return true;
114 | }
115 |
116 | return false;
117 | }
118 |
119 | public bool IsCryoOccupied(ulong steamId)
120 | {
121 | var currentIdField = typeof(MyCryoChamber).GetField("m_currentPlayerId", BindingFlags.NonPublic | BindingFlags.Instance);
122 |
123 | foreach (var chamber in CryoChambers)
124 | {
125 | var value = (MyPlayer.PlayerId?)currentIdField.GetValue(chamber);
126 | if (value?.SteamId == steamId)
127 | return true;
128 | }
129 |
130 | return false;
131 | }
132 |
133 | private readonly HashSet _projectors = new HashSet();
134 | private void DisableProjectors(MyCubeGrid grid)
135 | {
136 | foreach (var projector in grid.GetFatBlocks())
137 | {
138 | if (projector.ProjectedGrid == null)
139 | continue;
140 |
141 | projector.Enabled = false;
142 | _projectors.Add(projector.EntityId);
143 | }
144 | }
145 |
146 | public void EnableProjectors()
147 | {
148 | foreach (var projector in _projectors.Select(x => MyEntities.GetEntityById(x) as MyProjectorBase))
149 | {
150 | if (projector == null)
151 | continue;
152 |
153 | projector.Enabled = true;
154 | }
155 | _projectors.Clear();
156 | }
157 |
158 | ///
159 | /// Conceals this group from game and physics logic.
160 | ///
161 | public void Conceal()
162 | {
163 | foreach (var grid in Grids)
164 | {
165 | DisableProjectors(grid);
166 |
167 | if (grid.Parent == null)
168 | UnregisterRecursive(grid);
169 | }
170 |
171 | void UnregisterRecursive(MyEntity e)
172 | {
173 | if (e.IsPreview)
174 | return;
175 |
176 | MyEntities.UnregisterForUpdate(e);
177 | (e.GameLogic as IMyGameLogicComponent)?.UnregisterForUpdate();
178 | e.Flags |= (EntityFlags)4;
179 | if (e.Hierarchy == null)
180 | return;
181 |
182 | foreach (var child in e.Hierarchy.Children)
183 | UnregisterRecursive((MyEntity)child.Container.Entity);
184 | }
185 | }
186 |
187 | ///
188 | /// Reveals this group to game and physics logic.
189 | ///
190 | public void Reveal()
191 | {
192 | foreach (var grid in Grids)
193 | {
194 | if (grid.Parent == null)
195 | RegisterRecursive(grid);
196 | }
197 |
198 | EnableProjectors();
199 |
200 | void RegisterRecursive(MyEntity e)
201 | {
202 | if (e.IsPreview)
203 | return;
204 |
205 | MyEntities.RegisterForUpdate(e);
206 | (e.GameLogic as IMyGameLogicComponent)?.RegisterForUpdate();
207 | e.Flags &= ~(EntityFlags)4;
208 | if (e.Hierarchy == null)
209 | return;
210 |
211 | foreach (var child in e.Hierarchy.Children)
212 | RegisterRecursive((MyEntity)child.Container.Entity);
213 | }
214 | }
215 | }
216 |
217 | }
218 |
--------------------------------------------------------------------------------
/Concealment/Concealment.csproj:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | {E5C0184B-7DC4-43D8-872E-2F71162748AA}
6 | Library
7 | Properties
8 | Concealment
9 | Concealment
10 | v4.6.1
11 | 512
12 |
13 |
14 | true
15 | $(SolutionDir)\bin\x64\Debug\
16 | DEBUG;TRACE
17 | full
18 | x64
19 | prompt
20 | MinimumRecommendedRules.ruleset
21 |
22 |
23 | $(SolutionDir)\bin\x64\Release\
24 | TRACE
25 | true
26 | pdbonly
27 | x64
28 | prompt
29 | MinimumRecommendedRules.ruleset
30 |
31 |
32 |
33 | $(SolutionDir)\GameBinaries\HavokWrapper.dll
34 | False
35 |
36 |
37 | ..\packages\NLog.4.4.12\lib\net45\NLog.dll
38 | False
39 |
40 |
41 |
42 |
43 | $(SolutionDir)\GameBinaries\Sandbox.Common.dll
44 | False
45 |
46 |
47 | $(SolutionDir)\GameBinaries\Sandbox.Game.dll
48 | False
49 |
50 |
51 | $(SolutionDir)\GameBinaries\Sandbox.Graphics.dll
52 | False
53 |
54 |
55 | $(SolutionDir)\GameBinaries\SpaceEngineers.Game.dll
56 | False
57 |
58 |
59 | $(SolutionDir)\GameBinaries\SpaceEngineers.ObjectBuilders.dll
60 | False
61 |
62 |
63 | $(SolutionDir)\GameBinaries\SpaceEngineers.ObjectBuilders.XmlSerializers.dll
64 | False
65 |
66 |
67 | $(SolutionDir)\GameBinaries\SteamSDK.dll
68 | False
69 |
70 |
71 |
72 |
73 |
74 |
75 |
76 |
77 |
78 |
79 |
80 | False
81 | $(SolutionDir)\TorchBinaries\Torch.dll
82 | False
83 |
84 |
85 | False
86 | $(SolutionDir)\TorchBinaries\Torch.API.dll
87 | False
88 |
89 |
90 | $(SolutionDir)\GameBinaries\VRage.dll
91 | False
92 |
93 |
94 | $(SolutionDir)\GameBinaries\VRage.Audio.dll
95 | False
96 |
97 |
98 | $(SolutionDir)\GameBinaries\VRage.Dedicated.dll
99 | False
100 |
101 |
102 | $(SolutionDir)\GameBinaries\VRage.Game.dll
103 | False
104 |
105 |
106 | $(SolutionDir)\GameBinaries\VRage.Game.XmlSerializers.dll
107 | False
108 |
109 |
110 | $(SolutionDir)\GameBinaries\VRage.Input.dll
111 | False
112 |
113 |
114 | $(SolutionDir)\GameBinaries\VRage.Library.dll
115 | False
116 |
117 |
118 | $(SolutionDir)\GameBinaries\VRage.Math.dll
119 | False
120 |
121 |
122 | $(SolutionDir)\GameBinaries\VRage.Native.dll
123 | False
124 |
125 |
126 | $(SolutionDir)\GameBinaries\VRage.OpenVRWrapper.dll
127 | False
128 |
129 |
130 | $(SolutionDir)\GameBinaries\VRage.Render.dll
131 | False
132 |
133 |
134 | $(SolutionDir)\GameBinaries\VRage.Render11.dll
135 | False
136 |
137 |
138 | $(SolutionDir)\GameBinaries\VRage.Scripting.dll
139 | False
140 |
141 |
142 |
143 |
144 |
145 | Properties\AssemblyVersion.cs
146 |
147 |
148 |
149 |
150 | ConcealmentControl.xaml
151 |
152 |
153 |
154 | DynamicConcealmentEditor.xaml
155 |
156 |
157 |
158 |
159 |
160 |
161 |
162 | Designer
163 | MSBuild:Compile
164 |
165 |
166 | Designer
167 | MSBuild:Compile
168 |
169 |
170 |
171 |
172 |
173 |
174 |
175 |
176 |
177 |
--------------------------------------------------------------------------------
/Concealment/ConcealmentControl.xaml:
--------------------------------------------------------------------------------
1 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
24 |
25 |
26 |
27 |
28 |
29 |
30 |
31 |
32 |
33 |
34 |
35 |
36 |
37 |
38 |
39 |
40 |
41 |
42 |
43 |
44 |
45 |
46 |
47 |
48 |
49 |
50 |
51 |
52 |
53 |
54 |
55 |
56 |
57 |
58 |
59 |
--------------------------------------------------------------------------------
/Concealment/ConcealmentControl.xaml.cs:
--------------------------------------------------------------------------------
1 | #region
2 |
3 | using System.Linq;
4 | using System.Windows;
5 | using System.Windows.Controls;
6 | using Torch.Views;
7 |
8 | #endregion
9 |
10 | namespace Concealment
11 | {
12 | ///
13 | /// Interaction logic for ConcealmentControl.xaml
14 | ///
15 | public partial class ConcealmentControl : UserControl
16 | {
17 | public ConcealmentControl()
18 | {
19 | InitializeComponent();
20 | }
21 |
22 | public ConcealmentPlugin Plugin => (ConcealmentPlugin) DataContext;
23 |
24 | private void RevealSelected_OnClick(object sender, RoutedEventArgs e)
25 | {
26 | var groups = Concealed.SelectedItems.Cast().ToList();
27 | Concealed.SelectedItems.Clear();
28 | if (!groups.Any())
29 | return;
30 |
31 | var p = Plugin;
32 | Plugin.Torch.InvokeBlocking(delegate
33 | {
34 | foreach (var current in groups)
35 | p.RevealGroup(current);
36 | });
37 | }
38 |
39 | private void Reveal_OnClick(object sender, RoutedEventArgs e)
40 | {
41 | var p = Plugin;
42 | Plugin.Torch.Invoke(delegate { p.RevealGrids(p.Settings.Data.RevealDistance); });
43 | }
44 |
45 | private void Conceal_OnClick(object sender, RoutedEventArgs e)
46 | {
47 | var p = Plugin;
48 | Plugin.Torch.Invoke(delegate { p.ConcealGrids(p.Settings.Data.ConcealDistance); });
49 | }
50 |
51 | private void EditExclusion_OnClick(object sender, RoutedEventArgs e)
52 | {
53 | var editor = new CollectionEditor() {Owner = Window.GetWindow(this)};
54 | editor.Edit(Plugin.Settings.Data.ExcludedSubtypes, "Excluded Subtypes");
55 | }
56 |
57 | private void EditDynamicConcealment_OnClick(object sender, RoutedEventArgs e)
58 | {
59 | var editor = new DynamicConcealmentEditor
60 | {
61 | Owner = Window.GetWindow(this),
62 | DataContext = DataContext,
63 | WindowStartupLocation = WindowStartupLocation.CenterOwner
64 | };
65 | editor.ShowDialog();
66 | }
67 | }
68 | }
--------------------------------------------------------------------------------
/Concealment/ConcealmentPlugin.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Concurrent;
3 | using System.Collections.Generic;
4 | using System.Diagnostics;
5 | using System.IO;
6 | using System.Linq;
7 | using System.Threading;
8 | using System.Threading.Tasks;
9 | using System.Windows.Controls;
10 | using NLog;
11 | using Sandbox.Definitions;
12 | using Sandbox.Engine.Multiplayer;
13 | using Sandbox.Game.Entities;
14 | using Sandbox.Game.EntityComponents;
15 | using Sandbox.Game.Multiplayer;
16 | using Sandbox.Game.World;
17 | using Sandbox.ModAPI;
18 | using Torch;
19 | using Torch.API;
20 | using Torch.API.Managers;
21 | using Torch.API.Plugins;
22 | using Torch.API.Session;
23 | using Torch.Collections;
24 | using Torch.Managers;
25 | using Torch.Session;
26 | using VRage.Game;
27 | using VRage.Game.Components;
28 | using VRage.Game.Definitions;
29 | using VRage.Game.ModAPI;
30 | using VRage.Game.ObjectBuilders.ComponentSystem;
31 | using VRage.ModAPI;
32 | using VRageMath;
33 |
34 | namespace Concealment
35 | {
36 | public sealed class ConcealmentPlugin : TorchPluginBase, IWpfPlugin
37 | {
38 | public Persistent Settings { get; private set; }
39 | public MtObservableList ConcealedGroups { get; } = new MtObservableList();
40 |
41 | private readonly Dictionary _keepAliveTimers = new Dictionary();
42 | private static readonly Logger Log = LogManager.GetLogger("Concealment");
43 | private UserControl _control;
44 | private ulong _counter;
45 | private bool _init;
46 | private readonly List _intersectGroups;
47 | private MyDynamicAABBTreeD _concealedAabbTree;
48 | private bool _settingsChanged;
49 | private bool _ready;
50 |
51 | public ConcealmentPlugin()
52 | {
53 | _intersectGroups = new List();
54 | }
55 |
56 | UserControl IWpfPlugin.GetControl()
57 | {
58 | return _control ?? (_control = new ConcealmentControl { DataContext = this });
59 | }
60 |
61 | public override void Init(ITorchBase torch)
62 | {
63 | base.Init(torch);
64 | try
65 | {
66 | Settings = Persistent.Load(Path.Combine(StoragePath, "Concealment.cfg"));
67 | }
68 | catch (Exception e)
69 | {
70 | Log.Warn(e);
71 | }
72 | if (Settings?.Data == null)
73 | Settings = new Persistent(Path.Combine(StoragePath, "Concealment.cfg"), new Settings());
74 | Settings.Data.PropertyChanged += Data_PropertyChanged;
75 | _concealedAabbTree = new MyDynamicAABBTreeD(MyConstants.GAME_PRUNING_STRUCTURE_AABB_EXTENSION);
76 | torch.Managers.GetManager()?.AddFactory(CreateManager);
77 | }
78 |
79 | private IManager CreateManager(ITorchSession session)
80 | {
81 | return new DynamicConcealmentManager(this, session.Torch);
82 | }
83 |
84 | private void Data_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
85 | {
86 | _settingsChanged = true;
87 | }
88 |
89 | //TODO: divide conceal/reveal runs over several ticks to avoid stuttering.
90 | public override void Update()
91 | {
92 | if (MyAPIGateway.Session == null || !Settings.Data.Enabled)
93 | return;
94 |
95 | if (_ready)
96 | {
97 | if (_counter % (ulong)Settings.Data.ConcealInterval == 0)
98 | ConcealGrids(Settings.Data.ConcealDistance);
99 | if (_counter % (ulong)Settings.Data.RevealInterval == 0)
100 | RevealGrids(Settings.Data.RevealDistance);
101 | _counter += 1;
102 | }
103 |
104 | if (_init || MyAPIGateway.TerminalControls == null)
105 | return;
106 |
107 | //Make sure the game physics has time to initialize.
108 | var delayTimer = new System.Timers.Timer
109 | {
110 | AutoReset = false,
111 | Interval = 5000,
112 | };
113 |
114 | delayTimer.Elapsed += (sender, args) => _ready = true;
115 | delayTimer.Start();
116 |
117 | var keepAliveAction = MyAPIGateway.TerminalControls.CreateAction("Concealment.KeepAlive");
118 | keepAliveAction.Action = KeepAlive;
119 | MyAPIGateway.TerminalControls.AddAction(keepAliveAction);
120 |
121 | MyMultiplayer.Static.ClientJoined += RevealCryoPod;
122 |
123 | _init = true;
124 | }
125 |
126 | private void KeepAlive(IMyTerminalBlock block)
127 | {
128 | var rc = (IMyRemoteControl)block;
129 |
130 | if (rc.CubeGrid.IsStatic)
131 | return;
132 |
133 | Log.Debug($"Keepalive triggered on grid {block.CubeGrid.DisplayName}");
134 | var dueTime = TimeSpan.FromSeconds(Settings.Data.ConcealInterval / 60d);
135 | if (_keepAliveTimers.TryGetValue(block.CubeGrid.EntityId, out Timer timer))
136 | {
137 | timer.Change(dueTime, TimeSpan.Zero);
138 | }
139 | else
140 | {
141 | var newTimer = new Timer(KeepAliveCallback, block.CubeGrid.EntityId, dueTime, TimeSpan.Zero);
142 | _keepAliveTimers.Add(block.CubeGrid.EntityId, newTimer);
143 | }
144 | }
145 |
146 | private void KeepAliveCallback(object state)
147 | {
148 | var grid = (long)state;
149 | Log.Debug($"Keepalive expired on grid {grid}");
150 | Torch.Invoke(() =>
151 | {
152 | var timer = _keepAliveTimers[grid];
153 | timer.Dispose();
154 | _keepAliveTimers.Remove(grid);
155 | });
156 | }
157 |
158 | public override void Dispose()
159 | {
160 | Torch.Managers.GetManager()?.RemoveFactory(CreateManager);
161 | //RevealAll();
162 | Settings.Save(Path.Combine(StoragePath, "Concealment.cfg"));
163 | }
164 |
165 | public void GetConcealedGrids(List grids)
166 | {
167 | ConcealedGroups.SelectMany(x => x.Grids).ForEach(grids.Add);
168 | }
169 |
170 | private void RevealCryoPod(ulong steamId, string username)
171 | {
172 | Torch.Invoke(() =>
173 | {
174 | Log.Debug(nameof(RevealCryoPod));
175 | for (var i = ConcealedGroups.Count - 1; i >= 0; i--)
176 | {
177 | var group = ConcealedGroups[i];
178 |
179 | if (group.IsCryoOccupied(steamId))
180 | {
181 | RevealGroup(group);
182 | return;
183 | }
184 | }
185 | });
186 | }
187 |
188 | private void RevealSpawns(PlayerRequestArgs args)
189 | {
190 | Torch.Invoke(() =>
191 | {
192 | Log.Debug(nameof(RevealSpawns));
193 | var identityId = MySession.Static.Players.TryGetIdentityId(args.PlayerId.SteamId);
194 | if (identityId == 0)
195 | return;
196 |
197 | for (var i = ConcealedGroups.Count - 1; i >= 0; i--)
198 | {
199 | var group = ConcealedGroups[i];
200 |
201 | if (group.IsMedicalRoomAvailable(identityId))
202 | RevealGroup(group);
203 | }
204 | });
205 | }
206 |
207 |
208 | private int ConcealGroup(ConcealGroup group)
209 | {
210 | if (ConcealedGroups.Any(g => g.Id == group.Id))
211 | return 0;
212 |
213 | Log.Debug($"Concealing grids: {group.GridNames}");
214 | group.Conceal();
215 | /*foreach (var entity in group.Grids)
216 | entity.GetStorage().SetValue(Id, "True");*/
217 |
218 | group.UpdateAABB();
219 | var aabb = group.WorldAABB;
220 | group.ProxyId = _concealedAabbTree.AddProxy(ref aabb, group, 0);
221 | group.Closing += Group_Closing;
222 | Task.Run(() =>
223 | {
224 | group.UpdatePostConceal();
225 | Log.Debug($"Group {group.Id} cached");
226 | Torch.Invoke(() => ConcealedGroups.Add(group));
227 | });
228 | return group.Grids.Count;
229 | }
230 |
231 | private void Group_Closing(ConcealGroup group)
232 | {
233 | RevealGroup(group);
234 | }
235 |
236 | public int RevealGroup(ConcealGroup group)
237 | {
238 | if (!group.IsConcealed)
239 | {
240 | Log.Warn($"Attempted to reveal a group that wasn't concealed: {group.GridNames}");
241 | Log.Warn(new StackTrace());
242 | return 0;
243 | }
244 |
245 | var count = group.Grids.Count;
246 | Log.Debug($"Revealing grids: {group.GridNames}");
247 | group.Reveal();
248 | /*foreach (var entity in group.Grids)
249 | entity.GetStorage().SetValue(Id, "False");*/
250 |
251 | ConcealedGroups.Remove(group);
252 | _concealedAabbTree.RemoveProxy(group.ProxyId);
253 | group.UpdatePostReveal();
254 | return count;
255 | }
256 |
257 | public int RevealGridsInSphere(BoundingSphereD sphere)
258 | {
259 | var revealed = 0;
260 | _concealedAabbTree.OverlapAllBoundingSphere(ref sphere, _intersectGroups);
261 | Log.Trace($"{_intersectGroups.Count} groups");
262 | foreach (var group in _intersectGroups)
263 | revealed += RevealGroup(group);
264 |
265 | _intersectGroups.Clear();
266 | return revealed;
267 | }
268 |
269 | public int RevealGrids(double distanceFromPlayers)
270 | {
271 | var revealed = 0;
272 | var playerSpheres = GetPlayerViewSpheres(distanceFromPlayers);
273 | foreach (var sphere in playerSpheres)
274 | {
275 | Log.Trace($"{sphere.Center}: {sphere.Radius}");
276 | revealed += RevealGridsInSphere(sphere);
277 | }
278 |
279 | if (_settingsChanged)
280 | {
281 | for (var i = ConcealedGroups.Count - 1; i >= 0; i--)
282 | {
283 | if (IsExcluded(ConcealedGroups[i]))
284 | revealed += RevealGroup(ConcealedGroups[i]);
285 | }
286 |
287 | _settingsChanged = false;
288 | }
289 |
290 | if (revealed != 0)
291 | Log.Info($"Revealed {revealed} grids near players.");
292 | return revealed;
293 | }
294 |
295 | public int ConcealGrids(double distanceFromPlayers = 0)
296 | {
297 | Log.Debug("Concealing grids");
298 | int concealed = 0;
299 | var playerSpheres = GetPlayerViewSpheres(distanceFromPlayers);
300 |
301 | ConcurrentBag groups = new ConcurrentBag();
302 | var sw = Stopwatch.StartNew();
303 | Parallel.ForEach(MyCubeGridGroups.Static.Physical.Groups, group =>
304 | {
305 | var concealGroup = new ConcealGroup(group);
306 |
307 | if (distanceFromPlayers != 0)
308 | {
309 | var volume = group.GetWorldAABB();
310 | if (playerSpheres.Any(s => s.Contains(volume) != ContainmentType.Disjoint))
311 | {
312 | Log.Trace("group near player");
313 | return;
314 | }
315 | }
316 |
317 | if (IsExcluded(concealGroup))
318 | {
319 | Log.Trace("group excluded");
320 | return;
321 | }
322 |
323 | groups.Add(concealGroup);
324 | });
325 | Log.Debug($"Scanned grids in {sw.ElapsedMilliseconds}ms.");
326 | sw.Restart();
327 |
328 | foreach (var group in groups)
329 | {
330 | concealed += ConcealGroup(group);
331 | }
332 | Log.Debug($"Concealed grids in {sw.ElapsedMilliseconds}ms.");
333 | sw.Stop();
334 |
335 | var concealedCount = ConcealedGroups.SelectMany(x => x.Grids).Count();
336 | var totalCount = MyEntities.GetEntities().Count(x => x is MyCubeGrid);
337 |
338 | if (concealed > 0)
339 | Log.Info($"{concealedCount+concealed}/{totalCount} grids are concealed ({(concealedCount+concealed)/(float)totalCount:P}), {concealed} new.");
340 |
341 | return concealed;
342 | }
343 |
344 | public bool IsExcluded(ConcealGroup group)
345 | {
346 | var pirateId = MyPirateAntennas.GetPiratesId();
347 | foreach (var grid in group.Grids)
348 | {
349 | if (_keepAliveTimers.ContainsKey(grid.EntityId))
350 | {
351 | Log.Debug($"{group.GridNames} is kept alive by PB action");
352 | return true;
353 | }
354 |
355 | if (!Settings.Data.ConcealPirates && grid.BigOwners.Contains(pirateId))
356 | {
357 | Log.Debug($"{group.GridNames} is kept alive by pirate ownership");
358 | return true;
359 | }
360 | }
361 |
362 | var exclude = false;
363 | Parallel.ForEach(group.Grids, grid =>
364 | {
365 | foreach (var block in grid.CubeBlocks.Select(x => x.FatBlock))
366 | {
367 | if (block == null)
368 | continue;
369 |
370 | if (block is IMyProductionBlock p && !Settings.Data.ConcealProduction && p.IsProducing)
371 | {
372 | Log.Debug($"{group.GridNames} exempted production ({p.CustomName} active)");
373 | exclude = true;
374 | break;
375 | }
376 |
377 | if (Settings.Data.ExcludedSubtypes.Contains(block.BlockDefinition.Id.SubtypeName))
378 | {
379 | Log.Debug($"{group.GridNames} exempted subtype {block.BlockDefinition.Id.SubtypeName}");
380 | exclude = true;
381 | break;
382 | }
383 | }
384 | });
385 |
386 | return exclude;
387 | }
388 |
389 | public int RevealAll()
390 | {
391 | Log.Debug("Revealing all grids");
392 |
393 | var revealed = 0;
394 | for (var i = ConcealedGroups.Count - 1; i >= 0; i--)
395 | revealed += RevealGroup(ConcealedGroups[i]);
396 |
397 | return revealed;
398 | }
399 |
400 | private List GetPlayerViewSpheres(double distance)
401 | {
402 | return ((MyPlayerCollection)MyAPIGateway.Multiplayer.Players).GetOnlinePlayers().Select(p => new BoundingSphereD(p.GetPosition(), distance)).ToList();
403 | }
404 | }
405 |
406 | public static class Extensions
407 | {
408 | public static MyModStorageComponentBase GetStorage(this IMyEntity entity)
409 | {
410 | return entity.Storage = entity.Storage ?? new MyModStorageComponent();
411 | }
412 | }
413 | }
--------------------------------------------------------------------------------
/Concealment/DynamicConcealmentEditor.xaml:
--------------------------------------------------------------------------------
1 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
24 |
25 |
26 |
27 |
28 |
29 |
30 |
31 |
32 |
33 |
34 |
35 |
38 |
39 |
40 |
41 |
42 |
43 |
44 |
47 |
48 |
49 |
50 |
51 |
52 |
53 |
56 |
57 |
58 |
59 |
60 |
61 |
62 |
63 |
64 |
65 |
66 |
67 |
68 |
69 |
70 |
71 |
72 |
73 |
74 |
75 |
76 |
--------------------------------------------------------------------------------
/Concealment/DynamicConcealmentEditor.xaml.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.Linq;
4 | using System.Text;
5 | using System.Threading.Tasks;
6 | using System.Windows;
7 | using System.Windows.Controls;
8 | using System.Windows.Data;
9 | using System.Windows.Documents;
10 | using System.Windows.Input;
11 | using System.Windows.Media;
12 | using System.Windows.Media.Imaging;
13 | using System.Windows.Navigation;
14 | using System.Windows.Shapes;
15 |
16 | namespace Concealment
17 | {
18 | ///
19 | /// Interaction logic for DynamicConcealmentEditor.xaml
20 | ///
21 | public partial class DynamicConcealmentEditor : Window
22 | {
23 | public DynamicConcealmentEditor()
24 | {
25 | InitializeComponent();
26 | }
27 |
28 | private void ButtonBase_OnClick(object sender, RoutedEventArgs e)
29 | {
30 | var plugin = DataContext as ConcealmentPlugin;
31 | if (plugin == null) return;
32 | // ReSharper disable PossibleUnintendedReferenceComparison
33 | if (sender == OkayButton)
34 | {
35 | Close();
36 | } else if (sender == AddButton)
37 | {
38 | plugin.Settings.Data.DynamicConcealment.Add(new Settings.DynamicConcealSettings());
39 | } else if (sender == RemoveButton)
40 | {
41 | var entry = List.SelectedItem as Settings.DynamicConcealSettings;
42 | if (entry != null)
43 | plugin.Settings.Data.DynamicConcealment.Remove(entry);
44 | }
45 | // ReSharper restore PossibleUnintendedReferenceComparison
46 | }
47 | }
48 | }
49 |
--------------------------------------------------------------------------------
/Concealment/DynamicConcealmentManager.cs:
--------------------------------------------------------------------------------
1 | // #define DEBUG_DYNAMIC_CONCEAL_OWNERSHIP
2 |
3 | using System;
4 | using System.Collections.Concurrent;
5 | using System.Collections.Generic;
6 | using System.Collections.Specialized;
7 | using System.ComponentModel;
8 | using System.Linq;
9 | using System.Reflection;
10 | using System.Runtime.CompilerServices;
11 | using System.Runtime.InteropServices;
12 | using System.Text;
13 | using System.Threading;
14 | using System.Threading.Tasks;
15 | using NLog;
16 | using ParallelTasks;
17 | using Sandbox.Game.Entities;
18 | using Sandbox.Game.Entities.Character;
19 | using Sandbox.Game.Entities.Cube;
20 | using Sandbox.Game.Weapons;
21 | using Sandbox.Game.World;
22 | using Torch.API;
23 | using Torch.Managers;
24 | using Torch.Managers.PatchManager;
25 | using Torch.Utils;
26 | using VRage.Game;
27 | using VRage.Game.Entity;
28 | using VRage.Game.ModAPI;
29 | using VRage.Generics;
30 | using VRage.Groups;
31 | using VRage.ObjectBuilders;
32 | using VRageMath;
33 | using Task = ParallelTasks.Task;
34 |
35 | namespace Concealment
36 | {
37 | public class DynamicConcealmentManager : Manager
38 | {
39 | private static readonly Logger _log = LogManager.GetCurrentClassLogger();
40 | private static readonly TimeSpan _rebalanceTiming = TimeSpan.FromMinutes(5);
41 |
42 | [Dependency] private readonly PatchManager _patchManager;
43 |
44 | private PatchContext _ctx;
45 |
46 | // Icky, but statics everywhere
47 | private static readonly WeakReference _pluginRef = new WeakReference(null);
48 |
49 | private readonly ConcealmentPlugin _plugin;
50 | private readonly Timer _refreshCollection;
51 |
52 | private static TimeSpan QueryInterval
53 | {
54 | get
55 | {
56 | _pluginRef.TryGetTarget(out ConcealmentPlugin plugin);
57 | return TimeSpan.FromSeconds(plugin?.Settings?.Data?.DynamicConcealQueryInterval ?? 15);
58 | }
59 | }
60 |
61 | private static TimeSpan ScanInterval
62 | {
63 | get
64 | {
65 | _pluginRef.TryGetTarget(out ConcealmentPlugin plugin);
66 | return TimeSpan.FromSeconds(plugin?.Settings?.Data?.DynamicConcealScanInterval ?? 2);
67 | }
68 | }
69 |
70 | public DynamicConcealmentManager(ConcealmentPlugin plugin, ITorchBase torch) : base(torch)
71 | {
72 | _plugin = plugin;
73 | _pluginRef.SetTarget(plugin);
74 | _refreshCollection = new Timer(RefreshFromCollection);
75 | }
76 |
77 | ~DynamicConcealmentManager()
78 | {
79 | _refreshCollection?.Dispose();
80 | }
81 |
82 | #pragma warning disable 649
83 | [ReflectedGetter(Name = "m_objectFactory",
84 | TypeName = "Sandbox.Game.Entities.Cube.MyCubeBlockFactory, Sandbox.Game")]
85 | private static readonly Func> _cubeBlockFactory;
86 | #pragma warning restore 649
87 |
88 | ///
89 | public override void Attach()
90 | {
91 | if (_ctx == null)
92 | _ctx = _patchManager.AcquireContext();
93 | RefreshFromCollection(null);
94 | _patchManager.Commit();
95 | }
96 |
97 |
98 | private void DynamicConcealment_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
99 | {
100 | _refreshCollection.Change(1000 * 30, -1);
101 | }
102 |
103 | private void EntryOnPropertyChanged(object sender, PropertyChangedEventArgs propertyChangedEventArgs)
104 | {
105 | _refreshCollection.Change(1000 * 30, -1);
106 | }
107 |
108 | private void DetachCollection()
109 | {
110 | _plugin.Settings.Data.DynamicConcealment.CollectionChanged -= DynamicConcealment_CollectionChanged;
111 | foreach (var entry in _plugin.Settings.Data.DynamicConcealment)
112 | entry.PropertyChanged -= EntryOnPropertyChanged;
113 | }
114 |
115 | private void AttachCollection()
116 | {
117 | _plugin.Settings.Data.DynamicConcealment.CollectionChanged += DynamicConcealment_CollectionChanged;
118 | foreach (var entry in _plugin.Settings.Data.DynamicConcealment)
119 | entry.PropertyChanged += EntryOnPropertyChanged;
120 | }
121 |
122 | private void RefreshFromCollection(object _)
123 | {
124 | DetachCollection();
125 | AttachCollection();
126 | RebuildFromSettings(_plugin.Settings.Data.DynamicConcealment);
127 |
128 | foreach (var type in _genericConfig.Keys.Concat(_config.Keys.Select(x => x.TypeId)).Distinct())
129 | {
130 | try
131 | {
132 | var res = _cubeBlockFactory().TryGetProducedType(type);
133 | if (res == null)
134 | {
135 | _log.Warn($"Unable to determine entity type of OB type {type}");
136 | continue;
137 | }
138 | if (!typeof(MyEntity).IsAssignableFrom(res))
139 | {
140 | _log.Warn($"Type {res}, OB {type} isn't assignable to entity");
141 | continue;
142 | }
143 | DoPatch(res);
144 | }
145 | catch (Exception e)
146 | {
147 | _log.Error(e, $"Failed to attach to {type}");
148 | }
149 | }
150 | }
151 |
152 | ///
153 | public override void Detach()
154 | {
155 | DetachCollection();
156 | _patchManager.FreeContext(_ctx);
157 | }
158 |
159 | private static readonly string[] _patchTargets =
160 | {
161 | nameof(MyEntity.UpdateBeforeSimulation), nameof(MyEntity.UpdateBeforeSimulation10),
162 | nameof(MyEntity.UpdateBeforeSimulation100),
163 | nameof(MyEntity.UpdateAfterSimulation), nameof(MyEntity.UpdateAfterSimulation10),
164 | nameof(MyEntity.UpdateAfterSimulation100)
165 | };
166 |
167 | private static readonly MethodInfo _prefixUpdateMethod =
168 | typeof(DynamicConcealmentManager).GetMethod(nameof(PrefixUpdate),
169 | BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public) ??
170 | throw new Exception("Failed to find patch method");
171 |
172 | private void DoPatch(Type type)
173 | {
174 | while (true)
175 | {
176 | var patched = 0;
177 | foreach (var name in _patchTargets)
178 | {
179 | var target = type.GetMethod(name,
180 | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
181 | if (target != null)
182 | {
183 | // nop if it's already added.
184 | if (_ctx.GetPattern(target).Prefixes.Add(_prefixUpdateMethod))
185 | patched++;
186 | }
187 | }
188 | if (patched > 0)
189 | _log.Debug($"Attached dynamic concealment to {patched} new in {type}");
190 | if (type.BaseType == null || !typeof(MyEntity).IsAssignableFrom(type.BaseType))
191 | break;
192 | type = type.BaseType;
193 | }
194 | }
195 |
196 | private class DynamicConcealmentGridInfo : IPrioritizedWork
197 | {
198 | private readonly WeakReference _ref;
199 |
200 | internal DynamicConcealmentGridInfo(MyCubeGrid block)
201 | {
202 | _ref = new WeakReference(block);
203 | }
204 |
205 | internal readonly ReaderWriterLockSlim Lock = new ReaderWriterLockSlim();
206 | internal int ConfigVersion = -1;
207 | internal double NextQueryDistance;
208 | internal readonly List NearbyEntities = new List();
209 | internal DateTime LastNearbyUpdate;
210 | private Task _task;
211 |
212 | ~DynamicConcealmentGridInfo()
213 | {
214 | foreach (var k in NearbyEntities)
215 | k.Free();
216 | NearbyEntities.Clear();
217 | }
218 |
219 | public void DoWork(WorkData workData = null)
220 | {
221 | if (!_ref.TryGetTarget(out MyCubeGrid ent))
222 | return;
223 | BalanceTick(ent);
224 |
225 | var aabb = ent.PositionComp.WorldAABB.Inflate(NextQueryDistance);
226 |
227 | _entityListPool.AllocateOrCreate(out var list);
228 | if (list == null) list = new List();
229 | try
230 | {
231 | list.Clear();
232 | MyGamePruningStructure.GetTopMostEntitiesInBox(ref aabb, list, MyEntityQueryType.Static);
233 | var dt = (DateTime.Now - LastNearbyUpdate).TotalSeconds;
234 | aabb = aabb.Inflate(Math.Min(dt * 30, NextQueryDistance));
235 | MyGamePruningStructure.GetTopMostEntitiesInBox(ref aabb, list, MyEntityQueryType.Dynamic);
236 | using (Lock.WriteUsing())
237 | {
238 | foreach (var k in NearbyEntities)
239 | k.Free();
240 | NearbyEntities.Clear();
241 | foreach (var e in list)
242 | NearbyEntities.Add(GCHandle.Alloc(e, GCHandleType.Weak));
243 | }
244 | }
245 | finally
246 | {
247 | _entityListPool.Deallocate(list);
248 | }
249 | LastNearbyUpdate = DateTime.Now;
250 | }
251 |
252 | public WorkOptions Options { get; } = new WorkOptions() {MaximumThreads = 1};
253 |
254 | public void ScheduleRefresh()
255 | {
256 | lock (this)
257 | {
258 | if (_task.IsComplete)
259 | _task = ParallelTasks.Parallel.Start(this);
260 | }
261 | }
262 |
263 | public WorkPriority Priority => WorkPriority.Low;
264 | }
265 |
266 | private class DynamicConcealmentBlockInfo : IPrioritizedWork
267 | {
268 | private readonly WeakReference _ref;
269 |
270 | internal DynamicConcealmentBlockInfo(MyCubeBlock block)
271 | {
272 | _ref = new WeakReference(block);
273 | }
274 |
275 | internal int ConfigVersion = -1;
276 | internal bool ConcealState;
277 | internal DynamicConcealmentTargetInfo Config;
278 | internal DateTime LastConcealStateUpdate;
279 |
280 | private Task _task;
281 |
282 |
283 | public void DoWork(WorkData workData = null)
284 | {
285 | if (!_ref.TryGetTarget(out MyCubeBlock block))
286 | return;
287 | var gridInfo = GetConcealInfo(block.CubeGrid);
288 |
289 | // associate these queries per-grid
290 | gridInfo.NextQueryDistance = Math.Max(gridInfo.NextQueryDistance, Config.MaxDistance);
291 | if (gridInfo.LastNearbyUpdate + QueryInterval < DateTime.Now)
292 | {
293 | gridInfo.ScheduleRefresh();
294 | }
295 |
296 | #if DEBUG_DYNAMIC_CONCEAL_OWNERSHIP
297 | long[] ownerInfo = new long[2 * (int) Settings.DynamicConcealType.None];
298 | #endif
299 | double[] info = new double[(int) Settings.DynamicConcealType.None];
300 | for (var k = 0; k < info.Length; k++)
301 | info[k] = double.MaxValue;
302 | using (gridInfo.Lock.ReadUsing())
303 | foreach (var eid in gridInfo.NearbyEntities)
304 | {
305 | MyEntity ent = eid.Target as MyEntity;
306 | if (ent == null) continue;
307 |
308 | Settings.DynamicConcealType type = Settings.DynamicConcealType.None;
309 | long causingOwner = 0;
310 | if (ent is MyCubeGrid grid && grid != block.CubeGrid)
311 | {
312 | var worstRelation = 0;
313 | foreach (var otherOwner in grid.SmallOwners)
314 | {
315 | var relation = (int) GetRelationTolerant(block.OwnerId, otherOwner);
316 | if (relation > worstRelation)
317 | {
318 | causingOwner = otherOwner;
319 | worstRelation = relation;
320 | }
321 | }
322 | type = GetConcealType((MyRelationsBetweenPlayerAndBlock) worstRelation, true);
323 | }
324 | else if (ent is MyCharacter character)
325 | {
326 | causingOwner = character.GetPlayerIdentityId();
327 | type = GetConcealType(
328 | GetRelationTolerant(block.OwnerId, character.GetPlayerIdentityId()),
329 | false);
330 | }
331 | if (type != Settings.DynamicConcealType.None)
332 | {
333 | var dist = Vector3D.DistanceSquared(ent.PositionComp.WorldVolume.Center,
334 | block.PositionComp.WorldVolume.Center);
335 | if (dist < info[(int) type])
336 | {
337 | info[(int) type] = dist;
338 | #if DEBUG_DYNAMIC_CONCEAL_OWNERSHIP
339 | ownerInfo[2 * (int) type] = causingOwner;
340 | ownerInfo[2 * (int) type + 1] = ent.EntityId;
341 | #endif
342 | }
343 | }
344 | }
345 |
346 | var concealed = true;
347 | Settings.DynamicConcealType reason = Settings.DynamicConcealType.None;
348 | #if DEBUG_DYNAMIC_CONCEAL_OWNERSHIP
349 | var distanceFound = 0D;
350 | var distanceConfig = 0D;
351 | var reasonOwner = 0L;
352 | var reasonEntity = 0L;
353 | #endif
354 | for (var ri = 0; ri < info.Length; ri++)
355 | {
356 | var type = (Settings.DynamicConcealType) ri;
357 | var distSq = info[ri];
358 | var minDist = Config.Config.GetValueOrDefault(type, 0);
359 | if (distSq < minDist)
360 | {
361 | concealed = false;
362 | reason = type;
363 | #if DEBUG_DYNAMIC_CONCEAL_OWNERSHIP
364 | distanceFound = Math.Sqrt(distSq);
365 | distanceConfig = Math.Sqrt(minDist);
366 | reasonOwner = ownerInfo[2 * ri];
367 | reasonEntity = ownerInfo[2 * ri + 1];
368 | #endif
369 | break;
370 | }
371 | }
372 | #if DEBUG_DYNAMIC_CONCEAL_OWNERSHIP
373 | if (concealed != ConcealState)
374 | {
375 | if (concealed)
376 | _log.Debug(
377 | $"Concealing {block.CubeGrid.DisplayName} -> {(block as MyTerminalBlock)?.CustomName} -> {block.EntityId}");
378 | else
379 | _log.Debug(
380 | $"Revealing {block.CubeGrid.DisplayName} -> {(block as MyTerminalBlock)?.CustomName} -> {block.EntityId} ({distanceFound} < {distanceConfig}) b/c {reason}. "
381 | + $"Cause/Owner was {MySession.Static.Players.TryGetIdentity(reasonOwner)?.DisplayName ?? $"ID{reasonOwner}"}. "
382 | + $"Cause/Entity was {MyEntities.GetEntityById(reasonEntity)?.DisplayName ?? "unknown"}");
383 | }
384 | #endif
385 | ConcealState = concealed;
386 | LastConcealStateUpdate = DateTime.Now;
387 | }
388 |
389 | public WorkOptions Options { get; } = new WorkOptions() {MaximumThreads = 1};
390 |
391 | public void ScheduleRefresh()
392 | {
393 | lock (this)
394 | {
395 | if (_task.IsComplete)
396 | _task = ParallelTasks.Parallel.Start(this);
397 | }
398 | }
399 |
400 | public WorkPriority Priority => WorkPriority.Low;
401 | }
402 |
403 | private class DynamicConcealmentTargetInfo
404 | {
405 | ///
406 | /// Distances are squared
407 | ///
408 | public Dictionary Config { get; } =
409 | new Dictionary();
410 |
411 | ///
412 | /// Distance is _not_ squared
413 | ///
414 | public double MaxDistance;
415 |
416 | internal void Merge(Settings.DynamicConcealSettings s)
417 | {
418 | var d = s.Distance * s.Distance;
419 | if (!Config.TryGetValue(s.DynamicConcealType, out double cval) || cval < d)
420 | Config[s.DynamicConcealType] = d;
421 | MaxDistance = Math.Max(MaxDistance, s.Distance);
422 | }
423 |
424 | public override string ToString()
425 | {
426 | return $"DynConceal[{string.Join(", ", Config.Select(x => x.Key + "=" + x.Value))}]";
427 | }
428 | }
429 |
430 | private void RebuildFromSettings(ICollection config)
431 | {
432 | using (_configLock.WriteUsing())
433 | {
434 | _genericConfig.Clear();
435 | _config.Clear();
436 | foreach (var setting in config)
437 | {
438 | if (setting.Distance <= 0 || !setting.TargetTypeId.HasValue)
439 | {
440 | _log.Warn(
441 | $"Ignore setting {setting.TargetTypeIdString}/{setting.TargetSubtypeId} {setting.DynamicConcealType} {setting.Distance}");
442 | continue;
443 | }
444 | if (!string.IsNullOrWhiteSpace(setting.TargetSubtypeId)) continue;
445 | if (!_genericConfig.TryGetValue(setting.TargetTypeId.Value, out DynamicConcealmentTargetInfo val))
446 | val = _genericConfig[setting.TargetTypeId.Value] = new DynamicConcealmentTargetInfo();
447 | val.Merge(setting);
448 | _log.Debug(
449 | $"Register setting {setting.TargetTypeIdString}/{setting.TargetSubtypeId} {setting.DynamicConcealType} {setting.Distance}");
450 | }
451 | foreach (var setting in config)
452 | {
453 | if (setting.Distance <= 0 || !setting.TargetTypeId.HasValue)
454 | {
455 | _log.Warn(
456 | $"Ignore setting {setting.TargetTypeIdString}/{setting.TargetSubtypeId} {setting.DynamicConcealType} {setting.Distance}");
457 | continue;
458 | }
459 | if (string.IsNullOrWhiteSpace(setting.TargetSubtypeId)) continue;
460 | var id = new MyDefinitionId(setting.TargetTypeId.Value, setting.TargetSubtypeId);
461 | if (!_config.TryGetValue(id, out DynamicConcealmentTargetInfo val))
462 | val = _config[id] = new DynamicConcealmentTargetInfo();
463 | val.Merge(setting);
464 | _log.Debug(
465 | $"Register setting {setting.TargetTypeIdString}/{setting.TargetSubtypeId} {setting.DynamicConcealType} {setting.Distance}");
466 | }
467 | foreach (var nv in _config)
468 | {
469 | var baseConfig = _genericConfig.GetValueOrDefault(nv.Key.TypeId);
470 | if (baseConfig != null)
471 | foreach (var kv in baseConfig.Config)
472 | if (!nv.Value.Config.ContainsKey(kv.Key))
473 | {
474 | nv.Value.Config.Add(kv.Key, kv.Value);
475 | nv.Value.MaxDistance = Math.Max(nv.Value.MaxDistance, Math.Sqrt(kv.Value));
476 | }
477 | }
478 | _configVersion++;
479 | }
480 | }
481 |
482 | private static DynamicConcealmentTargetInfo QueryConfig(MyDefinitionId id)
483 | {
484 | if (_config.TryGetValue(id, out var res))
485 | return res;
486 | var type = id.TypeId;
487 | while (!type.IsNull)
488 | {
489 | if (_genericConfig.TryGetValue(type, out res))
490 | return res;
491 | type = ((Type) type).BaseType;
492 | }
493 | return null;
494 | }
495 |
496 | private static DynamicConcealmentBlockInfo GetConcealInfo(MyCubeBlock key)
497 | {
498 | var data = _blockUpdateInfo.GetValue(key, (x) => new DynamicConcealmentBlockInfo(x));
499 | if (data.ConfigVersion != _configVersion)
500 | using (_configLock.ReadUsing())
501 | {
502 | data.ConcealState = true;
503 | data.ConfigVersion = _configVersion;
504 | data.Config = QueryConfig(key.BlockDefinition.Id);
505 | data.LastConcealStateUpdate = new DateTime(0L);
506 | }
507 | return data;
508 | }
509 |
510 | private static DynamicConcealmentGridInfo GetConcealInfo(MyCubeGrid key)
511 | {
512 | var data = _gridUpdateInfo.GetValue(key, (x) => new DynamicConcealmentGridInfo(x));
513 | if (data.ConfigVersion != _configVersion)
514 | using (_configLock.ReadUsing())
515 | {
516 | data.ConfigVersion = _configVersion;
517 | data.NextQueryDistance = 0;
518 | data.NearbyEntities.Clear();
519 | data.LastNearbyUpdate = new DateTime(0L);
520 | }
521 | return data;
522 | }
523 |
524 | private static readonly ReaderWriterLockSlim _configLock =
525 | new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
526 |
527 | private static int _configVersion;
528 |
529 | private static readonly Dictionary _genericConfig
530 | = new Dictionary(MyObjectBuilderType.Comparer);
531 |
532 | private static readonly Dictionary _config =
533 | new Dictionary(MyDefinitionId.Comparer);
534 |
535 | private static readonly ConditionalWeakTable _blockUpdateInfo =
536 | new ConditionalWeakTable();
537 |
538 | private static readonly ConditionalWeakTable _gridUpdateInfo =
539 | new ConditionalWeakTable();
540 |
541 | private static DateTime _lastGridRebalance;
542 | private static readonly HashSet _gridRecastBalancing = new HashSet();
543 |
544 | private static readonly MyConcurrentObjectsPool> _entityListPool =
545 | new MyConcurrentObjectsPool>(8);
546 |
547 | ///
548 | /// Balances the rebuild queries for each grid out over time
549 | ///
550 | ///
551 | private static void BalanceTick(MyCubeGrid caller)
552 | {
553 | lock (_gridRecastBalancing)
554 | {
555 | _gridRecastBalancing.Add(caller.EntityId);
556 | if (_lastGridRebalance + _rebalanceTiming > DateTime.Now)
557 | {
558 | _gridRecastBalancing.Clear();
559 | var rawRebuildInterval = QueryInterval.Ticks;
560 | var rawBalancedInterval = QueryInterval.Ticks / _gridRecastBalancing.Count;
561 | var i = 0;
562 | foreach (var id in _gridRecastBalancing)
563 | {
564 | if (!MyEntities.TryGetEntityById(id, out MyEntity ent) || !(ent is MyCubeGrid grid))
565 | continue;
566 | var data = GetConcealInfo(grid);
567 | var lastUpdateRaw = data.LastNearbyUpdate.Ticks;
568 | var epoch = (lastUpdateRaw / rawRebuildInterval) + rawRebuildInterval;
569 | var balancedTime = epoch + rawBalancedInterval * i;
570 | if (balancedTime > lastUpdateRaw)
571 | data.LastNearbyUpdate = new DateTime(balancedTime - rawRebuildInterval);
572 | else
573 | data.LastNearbyUpdate = new DateTime(balancedTime);
574 | i++;
575 | }
576 | _lastGridRebalance = DateTime.Now;
577 | }
578 | }
579 | }
580 |
581 | // ReSharper disable once SuggestBaseTypeForParameter
582 | private static bool PrefixUpdate(MyEntity __instance)
583 | {
584 | var block = __instance as MyCubeBlock;
585 | if (block == null)
586 | return true;
587 | {
588 | if (block is MyLargeTurretBase turret && turret.IsControlledByLocalPlayer)
589 | return true;
590 | }
591 | var cfg = GetConcealInfo(block);
592 | if (cfg?.Config == null || cfg.Config.Config.Count == 0)
593 | return true;
594 |
595 | if (cfg.LastConcealStateUpdate + ScanInterval < DateTime.Now)
596 | {
597 | cfg.ScheduleRefresh();
598 | }
599 |
600 | return !cfg.ConcealState;
601 | }
602 |
603 | private static MyRelationsBetweenPlayerAndBlock GetRelationTolerant(long id1, long id2)
604 | {
605 | if (id1 == id2)
606 | return MyRelationsBetweenPlayerAndBlock.Owner;
607 | if (id1 == 0 || id2 == 0)
608 | return MyRelationsBetweenPlayerAndBlock.NoOwnership;
609 | IMyFaction playerFaction1 = MySession.Static.Factions.TryGetPlayerFaction(id1);
610 | IMyFaction playerFaction2 = MySession.Static.Factions.TryGetPlayerFaction(id2);
611 | if (playerFaction1 == null || playerFaction2 == null)
612 | return MyRelationsBetweenPlayerAndBlock.Enemies;
613 | if (playerFaction1 == playerFaction2)
614 | return MyRelationsBetweenPlayerAndBlock.FactionShare;
615 | return MySession.Static.Factions.GetRelationBetweenFactions(playerFaction1.FactionId,
616 | playerFaction2.FactionId).Item1 == MyRelationsBetweenFactions.Neutral
617 | ? MyRelationsBetweenPlayerAndBlock.Neutral
618 | : MyRelationsBetweenPlayerAndBlock.Enemies;
619 | }
620 |
621 | private static Settings.DynamicConcealType GetConcealType(MyRelationsBetweenPlayerAndBlock relation, bool grid)
622 | {
623 | switch (relation)
624 | {
625 | case MyRelationsBetweenPlayerAndBlock.Owner:
626 | case MyRelationsBetweenPlayerAndBlock.FactionShare:
627 | return grid ? Settings.DynamicConcealType.None : Settings.DynamicConcealType.FriendlyCharacters;
628 | case MyRelationsBetweenPlayerAndBlock.Enemies:
629 | return grid
630 | ? Settings.DynamicConcealType.HostileGrids
631 | : Settings.DynamicConcealType.HostileCharacters;
632 | case MyRelationsBetweenPlayerAndBlock.Neutral:
633 | case MyRelationsBetweenPlayerAndBlock.NoOwnership:
634 | default:
635 | return grid
636 | ? Settings.DynamicConcealType.NeutralGrids
637 | : Settings.DynamicConcealType.NeutralCharacters;
638 | }
639 | }
640 | }
641 | }
--------------------------------------------------------------------------------
/Concealment/Properties/AssemblyInfo.cs:
--------------------------------------------------------------------------------
1 | using System.Reflection;
2 | using System.Runtime.InteropServices;
3 |
4 | [assembly: AssemblyTitle("Concealment")]
5 | [assembly: AssemblyDescription("")]
6 | [assembly: AssemblyCompany("")]
7 | [assembly: AssemblyProduct("Torch")]
8 | [assembly: AssemblyCopyright("Copyright © Torch API 2017")]
9 | [assembly: AssemblyTrademark("")]
10 | [assembly: AssemblyCulture("")]
11 | [assembly: ComVisible(false)]
12 |
13 | #if DEBUG
14 | [assembly: AssemblyConfiguration("Debug")]
15 | #else
16 | [assembly: AssemblyConfiguration("Release")]
17 | #endif
--------------------------------------------------------------------------------
/Concealment/Settings.cs:
--------------------------------------------------------------------------------
1 | using System;
2 | using System.Collections.Generic;
3 | using System.ComponentModel;
4 | using System.IO;
5 | using System.Linq;
6 | using System.Runtime.CompilerServices;
7 | using System.Xml.Serialization;
8 | using NLog.Targets;
9 | using Sandbox.Definitions;
10 | using Torch;
11 | using Torch.Collections;
12 | using VRage.Game;
13 | using VRage.ObjectBuilders;
14 |
15 | namespace Concealment
16 | {
17 | public class Settings : ViewModel
18 | {
19 | private bool _enabled = true;
20 | private double _concealDistance = 75000;
21 | private int _concealInterval = 3600;
22 | private double _revealDistance = 50000;
23 | private int _revealInterval = 60;
24 | private bool _concealProduction;
25 | private bool _concealPirates;
26 |
27 | private double _dynamicConcealQueryInterval = 15;
28 | private double _dynamicConcealScanInterval = 2;
29 |
30 | ///
31 | /// Type of concealment constraint
32 | ///
33 | public enum DynamicConcealType
34 | {
35 | HostileCharacters = 0,
36 | NeutralCharacters,
37 | FriendlyCharacters,
38 | HostileGrids,
39 | NeutralGrids,
40 |
41 | // Must be last
42 | None
43 | }
44 |
45 | public class DynamicConcealSettings : ViewModel
46 | {
47 | private string _typeId;
48 | private string _subtypeId;
49 | private DynamicConcealType _concealType;
50 | private double _distance;
51 |
52 | ///
53 | /// Target type ID
54 | ///
55 | [XmlIgnore]
56 | public MyObjectBuilderType? TargetTypeId
57 | {
58 | get
59 | {
60 | if (MyObjectBuilderType.TryParse(_typeId, out var type))
61 | return type;
62 | if (MyObjectBuilderType.TryParse("MyObjectBuilder_" + _typeId, out type))
63 | return type;
64 | return null;
65 | }
66 | }
67 |
68 | ///
69 | /// Subtype ID to target, or null to target all subtypes
70 | ///
71 | [XmlAttribute("TargetSubtype")]
72 | [DefaultValue(null)]
73 | public string TargetSubtypeId
74 | {
75 | get => _subtypeId;
76 | set
77 | {
78 | _subtypeId = value;
79 | OnPropertyChanged();
80 | }
81 | }
82 |
83 | ///
84 | /// The assembly qualified name of the
85 | ///
86 | [XmlAttribute("TargetType")]
87 | public string TargetTypeIdString
88 | {
89 | get => _typeId?.Replace("MyObjectBuilder_", "") ?? "null";
90 | set
91 | {
92 | _typeId = value.Trim();
93 | OnPropertyChanged();
94 | // ReSharper disable once ExplicitCallerInfoArgument
95 | OnPropertyChanged(nameof(TargetSubtypeIdOptions));
96 | }
97 | }
98 |
99 | ///
100 | /// Type of concealment
101 | ///
102 | [XmlAttribute("Type")]
103 | public DynamicConcealType DynamicConcealType
104 | {
105 | get => _concealType;
106 | set => SetValue(ref _concealType, value);
107 | }
108 |
109 | ///
110 | /// Distance to conceal at
111 | ///
112 | [XmlAttribute("Distance")]
113 | public double Distance
114 | {
115 | get => _distance;
116 | set => SetValue(ref _distance, value);
117 | }
118 |
119 | [XmlIgnore]
120 | public ICollection TargetTypeIdOptions =>
121 | MyDefinitionManager.Static?.GetAllDefinitions()
122 | .OfType()
123 | .Select(x => x.Id.TypeId).Distinct()
124 | .Select(x => x.ToString().Replace("MyObjectBuilder_", "")).ToList() ??
125 | new List();
126 |
127 | [XmlIgnore]
128 | public ICollection TargetSubtypeIdOptions =>
129 | MyDefinitionManager.Static?.GetAllDefinitions()
130 | .OfType()
131 | .Where(x => TargetTypeId.HasValue && x.Id.TypeId == TargetTypeId.Value)
132 | .Select(x => x.Id.SubtypeName ?? "")
133 | .ToList() ?? new List();
134 |
135 | [XmlIgnore]
136 | public ICollection DynamicConcealTypeOptions =>
137 | ((DynamicConcealType[]) Enum.GetValues(typeof(DynamicConcealType)))
138 | .Where(x => x != DynamicConcealType.None).ToList();
139 | }
140 |
141 | [XmlIgnore]
142 | public MtObservableList ExcludedSubtypes { get; } = new MtObservableList();
143 |
144 | [XmlIgnore]
145 | public MtObservableList DynamicConcealment { get; } =
146 | new MtObservableList();
147 |
148 | public double DynamicConcealScanInterval
149 | {
150 | get => _dynamicConcealScanInterval;
151 | set => SetValue(ref _dynamicConcealScanInterval, value);
152 | }
153 |
154 | public double DynamicConcealQueryInterval
155 | {
156 | get => _dynamicConcealQueryInterval;
157 | set => SetValue(ref _dynamicConcealQueryInterval, value);
158 | }
159 |
160 | [XmlElement(nameof(DynamicConcealment))]
161 | public DynamicConcealSettings[] DynamicConcealmentSerial
162 | {
163 | get => DynamicConcealment.ToArray();
164 | set
165 | {
166 | DynamicConcealment.Clear();
167 | if (value != null)
168 | foreach (var k in value)
169 | DynamicConcealment.Add(k);
170 | }
171 | }
172 |
173 | [XmlElement(nameof(ExcludedSubtypes))]
174 | public string[] ExcludedSubtypesSerial
175 | {
176 | get => ExcludedSubtypes.ToArray();
177 | set
178 | {
179 | ExcludedSubtypes.Clear();
180 | if (value != null)
181 | foreach (var k in value)
182 | ExcludedSubtypes.Add(k);
183 | }
184 | }
185 |
186 | public bool Enabled
187 | {
188 | get => _enabled;
189 | set
190 | {
191 | _enabled = value;
192 | OnPropertyChanged();
193 | }
194 | }
195 |
196 | public int ConcealInterval
197 | {
198 | get => _concealInterval;
199 | set
200 | {
201 | _concealInterval = value;
202 | OnPropertyChanged();
203 | }
204 | }
205 |
206 | public int RevealInterval
207 | {
208 | get => _revealInterval;
209 | set
210 | {
211 | _revealInterval = value;
212 | OnPropertyChanged();
213 | }
214 | }
215 |
216 | public double ConcealDistance
217 | {
218 | get => _concealDistance;
219 | set
220 | {
221 | _concealDistance = value;
222 | OnPropertyChanged();
223 | }
224 | }
225 |
226 | public double RevealDistance
227 | {
228 | get => _revealDistance;
229 | set
230 | {
231 | _revealDistance = value;
232 | OnPropertyChanged();
233 | }
234 | }
235 |
236 | public bool ConcealProduction
237 | {
238 | get => _concealProduction;
239 | set
240 | {
241 | _concealProduction = value;
242 | OnPropertyChanged();
243 | }
244 | }
245 |
246 | public bool ConcealPirates
247 | {
248 | get => _concealPirates;
249 | set
250 | {
251 | _concealPirates = value;
252 | OnPropertyChanged();
253 | }
254 | }
255 | }
256 | }
--------------------------------------------------------------------------------
/Concealment/packages.config:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
--------------------------------------------------------------------------------
/Jenkins/PluginPush.exe:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/TorchAPI/Concealment/3049d87a9fc7c57c3c16b468cf94729c3f0c08bb/Jenkins/PluginPush.exe
--------------------------------------------------------------------------------
/Jenkins/jenkins-grab-se.ps1:
--------------------------------------------------------------------------------
1 | pushd
2 |
3 | $steamData = "C:/Steam/Data/"
4 | $steamCMDPath = "C:/Steam/steamcmd/"
5 | $steamCMDZip = "C:/Steam/steamcmd.zip"
6 |
7 | Add-Type -AssemblyName System.IO.Compression.FileSystem
8 |
9 | if (!(Test-Path $steamData)) {
10 | mkdir "$steamData"
11 | }
12 | if (!(Test-Path $steamCMDPath)) {
13 | if (!(Test-Path $steamCMDZip)) {
14 | (New-Object System.Net.WebClient).DownloadFile("https://steamcdn-a.akamaihd.net/client/installer/steamcmd.zip", "$steamCMDZip");
15 | }
16 | [System.IO.Compression.ZipFile]::ExtractToDirectory($steamCMDZip, $steamCMDPath)
17 | }
18 |
19 | cd "$steamData"
20 | & "$steamCMDPath/steamcmd.exe" "+login anonymous" "+force_install_dir $steamData" "+app_update 298740" "+quit"
21 |
22 | popd
--------------------------------------------------------------------------------
/Jenkins/release.ps1:
--------------------------------------------------------------------------------
1 | param([string] $ApiBase, [string]$tagName, [string]$authinfo, [string[]] $assetPaths)
2 | Add-Type -AssemblyName "System.Web"
3 |
4 | $headers = @{
5 | Authorization = "Basic " + [System.Convert]::ToBase64String([System.Text.Encoding]::ASCII.GetBytes($authinfo))
6 | Accept = "application/vnd.github.v3+json"
7 | }
8 | try
9 | {
10 | Write-Output("Checking if release with tag " + $tagName + " already exists...")
11 | $release = Invoke-RestMethod -Uri ($ApiBase+"releases/tags/$tagName") -Method "GET" -Headers $headers
12 | Write-Output(" Using existing release " + $release.id + " at " + $release.html_url)
13 | } catch {
14 | Write-Output(" Doesn't exist")
15 | $rel_arg = @{
16 | tag_name=$tagName
17 | name="Generated $tagName"
18 | body=""
19 | draft=$TRUE
20 | prerelease=$tagName.Contains("alpha") -or $tagName.Contains("beta")
21 | }
22 | Write-Output("Creating new release " + $tagName + "...")
23 | $release = Invoke-RestMethod -Uri ($ApiBase+"releases") -Method "POST" -Headers $headers -Body (ConvertTo-Json($rel_arg))
24 | Write-Output(" Created new release " + $tagName + " at " + $release.html_url)
25 | }
26 |
27 | $assetsApiBase = $release.assets_url
28 | Write-Output("Checking for existing assets...")
29 | $existingAssets = Invoke-RestMethod -Uri ($assetsApiBase) -Method "GET" -Headers $headers
30 | $assetLabels = ($assetPaths | ForEach-Object {[System.IO.Path]::GetFileName($_)})
31 | foreach ($asset in $existingAssets) {
32 | if ($assetLabels -contains $asset.name) {
33 | $uri = $asset.url
34 | Write-Output(" Deleting old asset " + $asset.name + " (id " + $asset.id + "); URI=" + $uri)
35 | $result = Invoke-RestMethod -Uri $uri -Method "DELETE" -Headers $headers
36 | }
37 | }
38 | Write-Output("Uploading assets...")
39 | $uploadUrl = $release.upload_url.Substring(0, $release.upload_url.LastIndexOf('{'))
40 | foreach ($asset in $assetPaths) {
41 | $assetName = [System.IO.Path]::GetFileName($asset)
42 | $assetType = [System.Web.MimeMapping]::GetMimeMapping($asset)
43 | $assetData = [System.IO.File]::ReadAllBytes($asset)
44 | $headerExtra = $headers + @{
45 | "Content-Type" = $assetType
46 | Name = $assetName
47 | }
48 | $uri = $uploadUrl + "?name=" + $assetName
49 | Write-Output(" Uploading " + $asset + " as " + $assetType + "; URI=" + $uri)
50 | $result = Invoke-RestMethod -Uri $uri -Method "POST" -Headers $headerExtra -Body $assetData
51 | Write-Output(" ID=" + $result.id + ", found at=" + $result.browser_download_url)
52 | }
--------------------------------------------------------------------------------
/Jenkinsfile:
--------------------------------------------------------------------------------
1 | def test_with_torch(branch)
2 | {
3 | try {
4 | stage('Acquire Torch ' + branch) {
5 | bat 'IF EXIST TorchBinaries RMDIR /S /Q TorchBinaries'
6 | bat 'mkdir TorchBinaries'
7 | step([$class: 'CopyArtifact', projectName: "Torch/Torch/${branch}", filter: "**/Torch*.dll", flatten: true, fingerprintArtifacts: true, target: "TorchBinaries"])
8 | step([$class: 'CopyArtifact', projectName: "Torch/Torch/${branch}", filter: "**/Torch*.exe", flatten: true, fingerprintArtifacts: true, target: "TorchBinaries"])
9 | }
10 |
11 | stage('Build + Torch ' + branch) {
12 | currentBuild.description = bat(returnStdout: true, script: '@powershell -File Versioning/version.ps1').trim()
13 | bat "IF EXIST \"bin\" rmdir /Q /S \"bin\""
14 | bat "IF EXIST \"bin-test\" rmdir /Q /S \"bin-test\""
15 | bat "\"${tool 'MSBuild'}msbuild\" Concealment.sln /p:Configuration=${buildMode} /p:Platform=x64 /t:Clean"
16 | bat "\"${tool 'MSBuild'}msbuild\" Concealment.sln /p:Configuration=${buildMode} /p:Platform=x64"
17 | }
18 |
19 |
20 | stage('Test + Torch ' + branch) {
21 | bat 'IF NOT EXIST reports MKDIR reports'
22 | bat "\"packages/xunit.runner.console.2.2.0/tools/xunit.console.exe\" \"bin-test/x64/${buildMode}/Concealment.Tests.dll\" -parallel none -xml \"reports/Concealment.Tests.xml\""
23 | step([
24 | $class: 'XUnitBuilder',
25 | thresholdMode: 1,
26 | thresholds: [[$class: 'FailedThreshold', failureThreshold: '1']],
27 | tools: [[
28 | $class: 'XUnitDotNetTestType',
29 | deleteOutputFiles: true,
30 | failIfNotNew: true,
31 | pattern: 'reports/*.xml',
32 | skipNoTestFiles: false,
33 | stopProcessingIfError: true
34 | ]]
35 | ])
36 | }
37 |
38 | return true
39 | } catch (e) {
40 | return false
41 | }
42 | }
43 |
44 | node('windows') {
45 | stage('Checkout') {
46 | checkout scm
47 | bat 'git pull --tags'
48 | }
49 |
50 | stage('Acquire SE') {
51 | bat 'powershell -File Jenkins/jenkins-grab-se.ps1'
52 | bat 'IF EXIST GameBinaries RMDIR GameBinaries'
53 | bat 'mklink /J GameBinaries "C:/Steam/Data/DedicatedServer64/"'
54 | }
55 |
56 | stage('Acquire NuGet Packages') {
57 | bat 'nuget restore Concealment.sln'
58 | }
59 |
60 | if (env.BRANCH_NAME == "master") {
61 | buildMode = "Release"
62 | } else {
63 | buildMode = "Debug"
64 | }
65 | result = test_with_torch("master")
66 | if (result) {
67 | currentBuild.result = "SUCCESS"
68 | stage('Archive') {
69 | archiveArtifacts artifacts: "bin/x64/${buildMode}/Concealment.*", caseSensitive: false, fingerprint: true, onlyIfSuccessful: true
70 |
71 | zipFile = "bin\\concealment.zip"
72 | packageDir = "bin\\concealment\\"
73 |
74 | bat "IF EXIST ${zipFile} DEL ${zipFile}"
75 | bat "IF EXIST ${packageDir} RMDIR /S /Q ${packageDir}"
76 |
77 | bat "xcopy bin\\x64\\${buildMode}\\Concealment.* ${packageDir}"
78 | powershell "(Get-Content manifest.xml).Replace('\${VERSION}', [System.Diagnostics.FileVersionInfo]::GetVersionInfo(\"\$PWD\\${packageDir}Concealment.dll\").ProductVersion) | Set-Content \"${packageDir}/manifest.xml\""
79 | powershell "Add-Type -Assembly System.IO.Compression.FileSystem; [System.IO.Compression.ZipFile]::CreateFromDirectory(\"\$PWD\\${packageDir}\", \"\$PWD\\${zipFile}\")"
80 | archiveArtifacts artifacts: zipFile, caseSensitive: false, onlyIfSuccessful: true
81 | }
82 | stage('Release') {
83 | withCredentials([usernamePassword(credentialsId: 'jimmacle-plugin-publish', usernameVariable: 'USERNAME', passwordVariable: 'TOKEN')]) {
84 | bat "Jenkins\\PluginPush.exe \"bin\\concealment.zip\" \"$USERNAME\" \"$TOKEN\""
85 | }
86 | }
87 | }
88 | else
89 | currentBuild.result = "FAIL"
90 | }
91 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Concealment
2 | Manages grid logic to disable unnecessary updates and improve server sim speed.
3 |
--------------------------------------------------------------------------------
/Setup (run before opening solution).bat:
--------------------------------------------------------------------------------
1 | :: This script creates a symlink to the game binaries to account for different installation directories on different systems.
2 |
3 | @echo off
4 | set /p path="Please enter the folder location of your SpaceEngineersDedicated.exe: "
5 | cd %~dp0
6 | mklink /J GameBinaries "%path%"
7 | if errorlevel 1 goto Error
8 | echo Done!
9 | goto End
10 | :Error
11 | echo An error occured creating the symlink.
12 | goto EndFinal
13 | :End
14 |
15 | set /p path="Please enter the folder location of your Torch.Server.exe: "
16 | cd %~dp0
17 | mklink /J TorchBinaries "%path%"
18 | if errorlevel 1 goto Error
19 | echo Done! You can now open the Torch solution without issue.
20 | goto EndFinal
21 | :Error2
22 | echo An error occured creating the symlink.
23 | :EndFinal
24 | pause
25 |
--------------------------------------------------------------------------------
/Versioning/AssemblyVersion.cs:
--------------------------------------------------------------------------------
1 | using System.Reflection;
2 |
3 | [assembly: AssemblyVersion("0.0.0.0")]
4 | [assembly: AssemblyInformationalVersion("v0.0.0-dev")]
5 |
--------------------------------------------------------------------------------
/Versioning/version.ps1:
--------------------------------------------------------------------------------
1 | $buildSalt = $Env:BUILD_NUMBER
2 | $gitVersion = git describe --tags
3 | $gitSimpleVersion = git describe --tags --abbrev=0
4 | $simpleVersionStandard = echo $gitSimpleVersion | Select-String -Pattern "([0-9]+)\.([0-9]+)\.([0-9]+)" | % {$_.Matches} | %{$_.Groups[1].Value+"."+$_.Groups[2].Value+"."+$_.Groups[3].Value}
5 | $dotNetVersion = "$simpleVersionStandard.$buildSalt"
6 | $infoVersion = "$gitVersion" -replace "([0-9]+)\.([0-9]+)\.([0-9]+)","$dotNetVersion"
7 |
8 | $fileContent = @"
9 | using System.Reflection;
10 |
11 | [assembly: AssemblyVersion("$dotNetVersion")]
12 | [assembly: AssemblyInformationalVersion("$infoVersion")]
13 | "@
14 |
15 | echo $fileContent | Set-Content "$PSScriptRoot/AssemblyVersion.cs"
16 |
17 | echo "$infoVersion"
--------------------------------------------------------------------------------
/manifest.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 | Concealment
4 | 17f44521-b77a-4e85-810f-ee73311cf75d
5 | TorchAPI/Concealment
6 | ${VERSION}
7 |
--------------------------------------------------------------------------------