public void InitTags()
{
if (!string.IsNullOrWhiteSpace(this.RemoteControl.CustomData))
{
var descSplit = this.RemoteControl.CustomData.Split('\n');
foreach (var tag in descSplit)
{
//TargetData
if (tag.Contains("[TargetData:") == true)
{
var tempValue = TagHelper.TagStringCheck(tag);
if (string.IsNullOrWhiteSpace(tempValue) == false)
{
byte[] byteData = { };
if (TagHelper.TargetObjectTemplates.TryGetValue(tempValue, out byteData) == true)
{
try {
var profile = MyAPIGateway.Utilities.SerializeFromBinary <TargetProfile>(byteData);
if (profile != null)
{
this.NormalData = profile;
Logger.MsgDebug(profile.ProfileSubtypeId + " Target Profile Loaded", DebugTypeEnum.BehaviorSetup);
}
} catch (Exception) {
}
}
}
}
//OverrideTargetData
if (tag.Contains("[OverrideTargetData:") == true)
{
var tempValue = TagHelper.TagStringCheck(tag);
if (string.IsNullOrWhiteSpace(tempValue) == false)
{
byte[] byteData = { };
if (TagHelper.TargetObjectTemplates.TryGetValue(tempValue, out byteData) == true)
{
try {
var profile = MyAPIGateway.Utilities.SerializeFromBinary <TargetProfile>(byteData);
if (profile != null)
{
this.OverrideData = profile;
Logger.MsgDebug(profile.ProfileSubtypeId + " Override Target Profile Loaded", DebugTypeEnum.BehaviorSetup);
}
} catch (Exception) {
}
}
}
}
}
}
}
public void TestWithNoBlob()
{
var test = new TestDescription(MethodBase.GetCurrentMethod().Name, this.GetType().Name);
ImageGenerator generator = new ImageGenerator(test.Name);
var img = generator.RenderImage();
TestImageHelper.SaveBitmap(test.FileName_Image, img);
Sink.ResetPoints();
var sut = new MarkerScanner(Sink.PromptNewMessage_Handler, Sink.OnAnchorSetEvent, Sink.OnMovingTipSetEvent);
var profile = new TargetProfile()
{
Centre = new BlobCentre()
{
X = 300, Y = 300
}, Color = System.Drawing.Color.FromArgb(255, 255, 255)
};
Sink.MyLog.Clear();
var pImg = sut.TryToSetAnchor(img, profile);
TestImageHelper.SaveBitmap(test.FileName_Processed, pImg as BitmapSource);
Assert.IsTrue(Sink.MyLog.Count > 2);
Assert.IsTrue(Sink.MyLog[Sink.MyLog.Count - 2].Contains("Unable to find reference point with size"));
Assert.IsTrue(Sink.MyLog[Sink.MyLog.Count - 1].Contains("No suitable marker for Anchor point not found"));
Assert.AreEqual(null, sut.Profile);
}
public PackageSettingsEntry(SettingsKey key, TargetPackage targetPackage = TargetPackage.All, TargetProfile targetProfile = TargetProfile.All)
{
SettingsKey = key;
DefaultValue = null;
TargetPackage = targetPackage;
TargetProfile = targetProfile;
}
public void TestWithNoPreset()
{
var test = new TestDescription(MethodBase.GetCurrentMethod().Name, this.GetType().Name);
ImageGenerator generator = new ImageGenerator(test.Name);
var img = generator.RenderImage();
TestImageHelper.SaveBitmap(test.FileName_Image, img);
Sink.ResetPoints();
var sut = new MarkerScanner(Sink.PromptNewMessage_Handler, Sink.OnAnchorSetEvent, Sink.OnMovingTipSetEvent);
var profile = new TargetProfile()
{
Centre = new BlobCentre()
{
X = 300, Y = 300
}, Color = System.Drawing.Color.FromArgb(255, 255, 255)
};
Sink.MyLog.Clear();
var pImg = sut.ProcessImage(img, 3);
TestImageHelper.SaveBitmap(test.FileName_Processed, pImg as BitmapSource);
Assert.IsTrue(Sink.MyLog.Count == 1);
Assert.IsTrue(Sink.MyLog[0].Contains("Anchor point not found. Please specify Anchor point first"));
Assert.AreEqual(null, sut.Profile);
}
public void InitTags()
{
if (!string.IsNullOrWhiteSpace(this.RemoteControl.CustomData))
{
var descSplit = this.RemoteControl.CustomData.Split('\n');
foreach (var tag in descSplit)
{
//TargetData
if (tag.Contains("[TargetData:") == true)
{
var tempValue = TagHelper.TagStringCheck(tag);
if (string.IsNullOrWhiteSpace(tempValue) == false)
{
byte[] byteData = { };
if (TagHelper.TargetObjectTemplates.TryGetValue(tempValue, out byteData) == true)
{
try {
var profile = MyAPIGateway.Utilities.SerializeFromBinary <TargetProfile>(byteData);
if (profile != null)
{
this.Data = profile;
}
} catch (Exception) {
}
}
}
}
}
}
}
public void TestWithCorrectPreset()
{
var test = new TestDescription(MethodBase.GetCurrentMethod().Name, this.GetType().Name);
ImageGenerator generator = new ImageGenerator(test.Name);
Marker vAncor = new Marker()
{
Center = ImageGenerator.DefaultCentre,
Diameter = 60,
Fill = Colors.Green,
Border = Colors.Gray
};
generator.AddMarkerToImage(vAncor);
Marker vTip = new Marker()
{
Center = ImageGenerator.DefaultCentre + new Vector(0, ImageGenerator.DefaultRadius),
Diameter = 100,
Fill = Colors.Blue,
Border = Colors.Gray
};
generator.AddMarkerToImage(vTip);
var img = generator.RenderImage();
TestImageHelper.SaveBitmap(test.FileName_Image, img);
var sut = new MarkerScanner(Sink.PromptNewMessage_Handler, Sink.OnAnchorSetEvent, Sink.OnMovingTipSetEvent);
var aProfile = new TargetProfile()
{
Centre = new BlobCentre(vAncor.Center, 0), Color = Extensions.SetColor(vAncor.Fill)
};
var mtProfile = new TargetProfile()
{
Centre = new BlobCentre(vTip.Center, 0), Color = Extensions.SetColor(vTip.Fill)
};
Sink.MyLog.Clear();
Sink.ResetPoints();
sut.TryToSetAnchor(img, aProfile);
sut.TryToSetTip(img, mtProfile);
var pImg = sut.ProcessImage(img, 1);
TestImageHelper.SaveBitmap(test.FileName_Processed, pImg as BitmapSource);
Assert.AreEqual(vAncor.Center.X, Sink.Anchor.C.X, 2);
Assert.AreEqual(vAncor.Center.Y, Sink.Anchor.C.Y, 2);
Assert.AreEqual(vAncor.Diameter, Sink.Anchor.D, 2);
Assert.AreEqual(aProfile.Centre.X, sut.Profile.Anchor.Initial.Centre.X);
Assert.AreEqual(aProfile.Centre.Y, sut.Profile.Anchor.Initial.Centre.Y);
Assert.AreEqual(aProfile.Centre.D, sut.Profile.Anchor.Initial.Centre.D);
Assert.AreEqual(vTip.Center.X, Sink.MovingTip.C.X, 2);
Assert.AreEqual(vTip.Center.Y, Sink.MovingTip.C.Y, 2);
Assert.AreEqual(vTip.Diameter, Sink.MovingTip.D, 2);
}
public List <Blob> FindBlobs(TargetProfile current, BitmapSource camImage)
{
PorcessedImg = BitmapImage2Bitmap(camImage);
BlobCounter blobCounter = AnalyzePicture(current, PorcessedImg);
blobCounter.ProcessImage(PorcessedImg);
return(blobCounter.GetObjectsInformation().ToList <Blob>());
}
public void TestWithTwoBlobAndOtherCorrectPosition()
{
var test = new TestDescription(MethodBase.GetCurrentMethod().Name, this.GetType().Name);
ImageGenerator generator = new ImageGenerator(test.Name);
Marker vAncor = new Marker()
{
Center = new Point(300, 400),
Diameter = 60,
Fill = Colors.Green,
Border = Colors.Gray
};
generator.AddMarkerToImage(vAncor);
Marker vTip = new Marker()
{
Center = new Point(900, 800),
Diameter = 100,
Fill = Colors.Green,
Border = Colors.Gray
};
generator.AddMarkerToImage(vTip);
var img = generator.RenderImage();
TestImageHelper.SaveBitmap(test.FileName_Image, img);
Sink.ResetPoints();
var sut = new MarkerScanner(Sink.PromptNewMessage_Handler, Sink.OnAnchorSetEvent, Sink.OnMovingTipSetEvent);
var profile = new TargetProfile()
{
Centre = new BlobCentre()
{
X = 900, Y = 800
}, Color = Extensions.SetColor(vAncor.Fill)
};
Sink.MyLog.Clear();
var pImg = sut.TryToSetAnchor(img, profile);
TestImageHelper.SaveBitmap(test.FileName_Processed, pImg as BitmapSource);
Assert.IsTrue(Sink.MyLog[Sink.MyLog.Count - 1].Contains("Anchor point set - Remaining dot preset as moving tip"));
Assert.AreEqual(900, Sink.Anchor.C.X, 2);
Assert.AreEqual(800, Sink.Anchor.C.Y, 2);
Assert.AreEqual(100, Sink.Anchor.D, 2);
Assert.AreEqual(profile.Centre.X, sut.Profile.Anchor.Initial.Centre.X);
Assert.AreEqual(profile.Centre.Y, sut.Profile.Anchor.Initial.Centre.Y);
Assert.AreEqual(profile.Centre.D, sut.Profile.Anchor.Initial.Centre.D);
Assert.AreEqual(300, Sink.MovingTip.C.X, 2);
Assert.AreEqual(400, Sink.MovingTip.C.Y, 2);
Assert.AreEqual(60, Sink.MovingTip.D, 2);
}
public static void VerifyServiceEnabled(TargetProfile supportedProfiles, [CallerMemberName] string caller = "")
{
if (InitOptions != null && InitOptions.ThrowOnValidateComponentErrors)
{
if (!supportedProfiles.HasFlag(MaterialComponents.Profile))
{
var errorMessage = $"{caller} method is not supported on {MaterialComponents.Profile} profile. "
+ $"if you want to check how it works without throwing an exception, please set ComponentsOptions.All when you call MaterialComponents.Init(). ";
throw new NotSupportedException(errorMessage);
}
}
}
private static bool SupportsTargetProfile(Compiler compiler, TargetProfile targetProfile)
{
switch (targetProfile)
{
case TargetProfile.cs_6_0:
case TargetProfile.ds_6_0:
case TargetProfile.gs_6_0:
case TargetProfile.hs_6_0:
case TargetProfile.ps_6_0:
case TargetProfile.vs_6_0:
return(compiler == Compiler.NewCompiler);
default:
return(compiler == Compiler.OldCompiler);
}
}
public RapidTypeAnalysis(WholeProgram wholeProgram, TargetProfile profile)
{
Contract.Ensures(!this.FinishedAnalysis);
this.types = new HashSet <ITypeDefinition>(new TypeDefinitionEqualityComparer());
this.methods = new HashSet <IMethodDefinition>(new MethodDefinitionEqualityComparer());
this.virtualCallsInDemand = new VirtualDispatchDemand();
this.nonvirtualDispatches = new HashSet <IMethodDefinition>(new MethodDefinitionEqualityComparer());
this.fields = new HashSet <IFieldDefinition>(new FieldDefinitionEqualityComparer());
this.constructed = new HashSet <ITypeDefinition>(new TypeDefinitionEqualityComparer());
this.constructedGenericParameters = new HashSet <IGenericParameter>(new TypeDefinitionEqualityComparer());
// Note: we use the interned key as the hashcode, so this set should be deterministic
this.worklist = new HashSet <IMethodDefinition>(new MethodDefinitionEqualityComparer());
this.wholeProgram = wholeProgram;
this.reflectionSummarizers = new HashSet <IMethodSummarizer>();
this.simpleBytecodeSummarizer = new SimpleBytecodeMethodSummarizer();
this.reachabilityFlowBytecodeSummarizer = new ReachabilityBasedLocalFlowMethodSummarizer();
//systemObjectType = wholeProgram.Host().PlatformType.SystemObject.ResolvedType;
// Weak heuristic -- should provide custom host?
IAssembly coreAssembly = wholeProgram.HeuristicFindCoreAssemblyForProfile(profile);
Contract.Assert(coreAssembly != null);
systemObjectType = GarbageCollectHelper.CreateTypeReference(wholeProgram.Host(), coreAssembly, "System.Object").ResolvedType;
Contract.Assert(!(systemObjectType is Dummy));
systemObjectFinalizeMethod = TypeHelper.GetMethod(systemObjectType, wholeProgram.Host().NameTable.GetNameFor("Finalize"));
Contract.Assert(!(systemObjectFinalizeMethod is Dummy));
methodsRequiringReflectionSummary = new HashSet <IMethodDefinition>(new MethodDefinitionEqualityComparer());
unresolvedReferences = new HashSet <IReference>(new ReferenceEqualityComparer());
unspecializedTypesPassedAsTypeVariables = new HashSet <ITypeDefinition>(new TypeDefinitionEqualityComparer());
}
public RapidTypeAnalysis(WholeProgram wholeProgram, TargetProfile profile) {
Contract.Ensures(!this.FinishedAnalysis);
this.types = new HashSet<ITypeDefinition>(new TypeDefinitionEqualityComparer());
this.methods = new HashSet<IMethodDefinition>(new MethodDefinitionEqualityComparer());
this.virtualCallsInDemand = new VirtualDispatchDemand();
this.nonvirtualDispatches = new HashSet<IMethodDefinition>(new MethodDefinitionEqualityComparer());
this.fields = new HashSet<IFieldDefinition>(new FieldDefinitionEqualityComparer());
this.constructed = new HashSet<ITypeDefinition>(new TypeDefinitionEqualityComparer());
this.constructedGenericParameters = new HashSet<IGenericParameter>(new TypeDefinitionEqualityComparer());
// Note: we use the interned key as the hashcode, so this set should be deterministic
this.worklist = new HashSet<IMethodDefinition>(new MethodDefinitionEqualityComparer());
this.wholeProgram = wholeProgram;
this.reflectionSummarizers = new HashSet<IMethodSummarizer>();
this.simpleBytecodeSummarizer = new SimpleBytecodeMethodSummarizer();
this.reachabilityFlowBytecodeSummarizer = new ReachabilityBasedLocalFlowMethodSummarizer();
//systemObjectType = wholeProgram.Host().PlatformType.SystemObject.ResolvedType;
// Weak heuristic -- should provide custom host?
IAssembly coreAssembly = wholeProgram.HeuristicFindCoreAssemblyForProfile(profile);
Contract.Assert(coreAssembly != null);
systemObjectType = GarbageCollectHelper.CreateTypeReference(wholeProgram.Host(), coreAssembly, "System.Object").ResolvedType;
Contract.Assert(!(systemObjectType is Dummy));
systemObjectFinalizeMethod = TypeHelper.GetMethod(systemObjectType, wholeProgram.Host().NameTable.GetNameFor("Finalize"));
Contract.Assert(!(systemObjectFinalizeMethod is Dummy));
methodsRequiringReflectionSummary = new HashSet<IMethodDefinition>(new MethodDefinitionEqualityComparer());
unresolvedReferences = new HashSet<IReference>(new ReferenceEqualityComparer());
unspecializedTypesPassedAsTypeVariables = new HashSet<ITypeDefinition>(new TypeDefinitionEqualityComparer());
}
public NewTargetingSystem(IMyRemoteControl remoteControl = null)
{
RemoteControl = remoteControl;
Target = new PlayerEntity(null);
Data = new TargetProfile();
LastAcquisitionTime = MyAPIGateway.Session.GameDateTime;
LastRefreshTime = MyAPIGateway.Session.GameDateTime;
LastEvaluationTime = MyAPIGateway.Session.GameDateTime;
TargetLastKnownCoords = Vector3D.Zero;
ForceRefresh = false;
ForceTargetEntity = 0;
TargetAlreadyEvaluated = false;
UseNewTargetProfile = false;
ResetTimerOnProfileChange = false;
NewTargetProfileName = "";
}
public IAssembly HeuristicFindCoreAssemblyForProfile(TargetProfile profile)
{
IAssembly coreAssembly = null;
switch (profile)
{
case TargetProfile.Desktop:
case TargetProfile.Phone:
foreach (IAssembly assembly in allAssemblies)
{
if (assembly.AssemblyIdentity.Equals(host.CoreAssemblySymbolicIdentity))
{
coreAssembly = assembly;
break;
}
}
break;
}
return(coreAssembly);
}
private static StubMethodBodyEmitter GetStubMethodBodyEmitterForProfile(TargetProfile profile, WholeProgram wholeProgram)
{
StubMethodBodyEmitter emitter;
switch (profile)
{
case TargetProfile.Desktop:
emitter = new DotNetDesktopStubMethodBodyEmitter(wholeProgram.Host());
break;
case TargetProfile.Phone:
emitter = new WindowsPhoneStubMethodBodyEmitter(wholeProgram.Host());
break;
default:
emitter = new DotNetDesktopStubMethodBodyEmitter(wholeProgram.Host());
break;
}
return(emitter);
}
private static void TransformProgram(WholeProgram wholeProgram,
string transformedBinariesPath,
string reportsPath,
MethodRemoval methodRemoval,
TargetProfile profile)
{
System.IO.Directory.CreateDirectory(transformedBinariesPath);
StubMethodBodyEmitter stubEmitter = GetStubMethodBodyEmitterForProfile(profile, wholeProgram);
foreach (IAssembly assembly in wholeProgram.AllAssemblies())
{
if (AssemblyShouldBeRewritten(assembly))
{
if (assembly.PublicKeyToken.Count() > 0)
{
Console.WriteLine("Warning: rewriting assembly with a public key token. {0}", assembly);
}
string outputBinary = transformedBinariesPath + @"\" + Path.GetFileName(assembly.Location);
var copy = new MetadataDeepCopier(wholeProgram.Host()).Copy(assembly);
DocumentationCommentDefinitionIdStringMap idMap = new DocumentationCommentDefinitionIdStringMap(new IAssembly[] { copy });
AssemblyReport assemblyReport = AssemblyReport.CreateAssemblyReportFromPath(copy, reportsPath, idMap);
stopwatch.Start();
RewriteBinary(copy, assemblyReport, wholeProgram.Host(), outputBinary, methodRemoval, stubEmitter);
stopwatch.Start();
}
else
{
//Console.WriteLine("Skipping rewrite of of assembly {0}", assembly.Name.Value);
}
}
}
public void SetTargetProfile()
{
UseNewTargetProfile = false;
byte[] targetProfileBytes;
if (!TagHelper.TargetObjectTemplates.TryGetValue(NewTargetProfileName, out targetProfileBytes))
{
return;
}
TargetProfile targetProfile;
try {
targetProfile = MyAPIGateway.Utilities.SerializeFromBinary <TargetProfile>(targetProfileBytes);
if (targetProfile != null && !string.IsNullOrWhiteSpace(targetProfile.ProfileSubtypeId))
{
Data = targetProfile;
_settings.CustomTargetProfile = NewTargetProfileName;
}
} catch (Exception e) {
}
}
public BlobCounter AnalyzePicture(TargetProfile target, System.Drawing.Bitmap porcessedImg)
{
EuclideanColorFiltering filter = new EuclideanColorFiltering();
filter.CenterColor = new RGB(target.Color);
filter.Radius = target.FilterRadius;
filter.ApplyInPlace(porcessedImg);
BlobCounter blobCounter = new BlobCounter();
blobCounter.MinWidth = target.MinSize;
blobCounter.MinHeight = target.MinSize;
blobCounter.FilterBlobs = true;
blobCounter.ObjectsOrder = ObjectsOrder.Size;
blobCounter.MaxWidth = blobCounter.MaxHeight = target.MaxSize;
System.Drawing.Imaging.BitmapData objectsData = porcessedImg.LockBits(new System.Drawing.Rectangle(0, 0, porcessedImg.Width, porcessedImg.Height), ImageLockMode.ReadOnly, porcessedImg.PixelFormat);
Grayscale grayscaleFilter = new Grayscale(0.2125, 0.7154, 0.0721);
UnmanagedImage grayImage = grayscaleFilter.Apply(new UnmanagedImage(objectsData));
porcessedImg.UnlockBits(objectsData);
return(blobCounter);
}
public void TestWithOneBlobAndCorrectPositionButWrongColor()
{
var test = new TestDescription(MethodBase.GetCurrentMethod().Name, this.GetType().Name);
ImageGenerator generator = new ImageGenerator(test.Name);
Marker vAncor = new Marker()
{
Center = new Point(300, 300),
Diameter = 60,
Fill = Colors.Green,
Border = Colors.Gray
};
generator.AddMarkerToImage(vAncor);
var img = generator.RenderImage();
TestImageHelper.SaveBitmap(test.FileName_Image, img);
Sink.ResetPoints();
var sut = new MarkerScanner(Sink.PromptNewMessage_Handler, Sink.OnAnchorSetEvent, Sink.OnMovingTipSetEvent);
var profile = new TargetProfile()
{
Centre = new BlobCentre()
{
X = 300, Y = 300
}, Color = Extensions.SetColor(Colors.Blue)
};
Sink.MyLog.Clear();
var pImg = sut.TryToSetAnchor(img, profile);
TestImageHelper.SaveBitmap(test.FileName_Processed, pImg as BitmapSource);
Assert.IsTrue(Sink.MyLog.Count >= 1);
Assert.IsTrue(Sink.MyLog[Sink.MyLog.Count - 1].Contains("No suitable marker for Anchor point not found"));
Assert.AreEqual(null, sut.Profile);
}
public void TestWithNoTipPreset()
{
var test = new TestDescription(MethodBase.GetCurrentMethod().Name, this.GetType().Name);
ImageGenerator generator = new ImageGenerator(test.Name);
Marker vAncor = new Marker()
{
Center = new Point(300, 300),
Diameter = 60,
Fill = Colors.Green,
Border = Colors.Gray
};
generator.AddMarkerToImage(vAncor);
var img = generator.RenderImage();
TestImageHelper.SaveBitmap(test.FileName_Image, img);
Sink.ResetPoints();
var sut = new MarkerScanner(Sink.PromptNewMessage_Handler, Sink.OnAnchorSetEvent, Sink.OnMovingTipSetEvent);
var profile = new TargetProfile()
{
Centre = new BlobCentre()
{
X = 300, Y = 300
}, Color = Extensions.SetColor(vAncor.Fill)
};
sut.TryToSetAnchor(img, profile);
Sink.MyLog.Clear();
var pImg = sut.ProcessImage(img, 3);
TestImageHelper.SaveBitmap(test.FileName_Processed, pImg as BitmapSource);
Assert.IsTrue(Sink.MyLog.Count == 1);
Assert.IsTrue(Sink.MyLog[0].Contains("Moving point not found. Please specify Moving point first"));
}
public void SetTargetProfile(bool setOverride = false)
{
UseNewTargetProfile = false;
byte[] targetProfileBytes;
if (!TagHelper.TargetObjectTemplates.TryGetValue(NewTargetProfileName, out targetProfileBytes))
{
Logger.MsgDebug("No Target Profile For: " + NewTargetProfileName, DebugTypeEnum.Target);
return;
}
TargetProfile targetProfile;
try {
targetProfile = MyAPIGateway.Utilities.SerializeFromBinary <TargetProfile>(targetProfileBytes);
if (targetProfile != null && !string.IsNullOrWhiteSpace(targetProfile.ProfileSubtypeId))
{
if (!setOverride)
{
NormalData = targetProfile;
_behavior.Settings.CustomTargetProfile = NewTargetProfileName;
Logger.MsgDebug("Target Profile Switched To: " + NewTargetProfileName, DebugTypeEnum.Target);
}
else
{
OverrideData = targetProfile;
_behavior.Settings.CustomTargetProfile = NewTargetProfileName;
Logger.MsgDebug("Target Profile Switched To: " + NewTargetProfileName, DebugTypeEnum.Target);
}
}
} catch (Exception e) {
Logger.MsgDebug("Target Profile Exception: " + NewTargetProfileName, DebugTypeEnum.Target);
Logger.MsgDebug(e.ToString(), DebugTypeEnum.Target);
}
}
private static RapidTypeAnalysis RunRTA(WholeProgram wholeProgram,
IEnumerable <ILGarbageCollect.Summaries.IMethodSummarizer> reflectionSummarizers,
IEnumerable <IMethodReference> entryPoints,
string reportPath,
TargetProfile profile)
{
var rta = new RapidTypeAnalysis(wholeProgram, profile);
rta.ReflectionSummarizers = reflectionSummarizers;
Console.WriteLine("Running Rapid Type Analysis with {0} entry points", entryPoints.Count());
rta.Run(entryPoints);
stopwatch.Stop();
OutputRTAStatistics(rta, reportPath);
return(rta);
}
public static void TargetResponse(NetState state, CircularBufferReader reader, int packetLength)
{
int type = reader.ReadByte();
var targetID = reader.ReadInt32();
int flags = reader.ReadByte();
var serial = (Serial)reader.ReadUInt32();
int x = reader.ReadInt16();
int y = reader.ReadInt16();
reader.ReadByte();
int z = reader.ReadSByte();
int graphic = reader.ReadUInt16();
if (targetID == unchecked ((int)0xDEADBEEF))
{
return;
}
var from = state.Mobile;
var t = from.Target;
if (t == null)
{
return;
}
var prof = TargetProfile.Acquire(t.GetType());
prof?.Start();
try
{
if (x == -1 && y == -1 && !serial.IsValid)
{
// User pressed escape
t.Cancel(from, TargetCancelType.Canceled);
}
else if (t.TargetID != targetID)
{
// Sanity, prevent fake target
}
else
{
object toTarget;
if (type == 1)
{
if (graphic == 0)
{
toTarget = new LandTarget(new Point3D(x, y, z), from.Map);
}
else
{
var map = from.Map;
if (map == null || map == Map.Internal)
{
t.Cancel(from, TargetCancelType.Canceled);
return;
}
else
{
var tiles = map.Tiles.GetStaticTiles(x, y, !t.DisallowMultis);
var valid = false;
if (state.HighSeas)
{
var id = TileData.ItemTable[graphic & TileData.MaxItemValue];
if (id.Surface)
{
z -= id.Height;
}
}
for (var i = 0; !valid && i < tiles.Length; ++i)
{
if (tiles[i].Z == z && tiles[i].ID == graphic)
{
valid = true;
}
}
if (!valid)
{
t.Cancel(from, TargetCancelType.Canceled);
return;
}
else
{
toTarget = new StaticTarget(new Point3D(x, y, z), graphic);
}
}
}
}
else if (serial.IsMobile)
{
toTarget = World.FindMobile(serial);
}
else if (serial.IsItem)
{
toTarget = World.FindItem(serial);
}
else
{
t.Cancel(from, TargetCancelType.Canceled);
return;
}
t.Invoke(from, toTarget);
}
}
finally
{
prof?.Finish();
}
}
public static void Setup()
{
var definitionList = MyDefinitionManager.Static.GetEntityComponentDefinitions();
//Get All Chat, Spawner
foreach (var def in definitionList)
{
try {
if (string.IsNullOrWhiteSpace(def.DescriptionText) == true)
{
continue;
}
if (def.DescriptionText.Contains("[RivalAI Chat]") == true && ChatObjectTemplates.ContainsKey(def.Id.SubtypeName) == false)
{
var chatObject = new ChatProfile();
chatObject.InitTags(def.DescriptionText);
chatObject.ProfileSubtypeId = def.Id.SubtypeName;
var chatBytes = MyAPIGateway.Utilities.SerializeToBinary <ChatProfile>(chatObject);
//Logger.WriteLog("Chat Profile Added: " + def.Id.SubtypeName);
ChatObjectTemplates.Add(def.Id.SubtypeName, chatBytes);
continue;
}
if (def.DescriptionText.Contains("[RivalAI Spawn]") == true && SpawnerObjectTemplates.ContainsKey(def.Id.SubtypeName) == false)
{
var spawnerObject = new SpawnProfile();
spawnerObject.InitTags(def.DescriptionText);
spawnerObject.ProfileSubtypeId = def.Id.SubtypeName;
var spawnerBytes = MyAPIGateway.Utilities.SerializeToBinary <SpawnProfile>(spawnerObject);
//Logger.WriteLog("Spawner Profile Added: " + def.Id.SubtypeName);
SpawnerObjectTemplates.Add(def.Id.SubtypeName, spawnerBytes);
continue;
}
} catch (Exception) {
Logger.MsgDebug(string.Format("Caught Error While Processing Definition {0}", def.Id));
}
}
foreach (var def in definitionList)
{
try {
if (string.IsNullOrWhiteSpace(def.DescriptionText) == true)
{
continue;
}
if (def.DescriptionText.Contains("[RivalAI Action]") == true && ActionObjectTemplates.ContainsKey(def.Id.SubtypeName) == false)
{
var actionObject = new ActionProfile();
actionObject.InitTags(def.DescriptionText);
actionObject.ProfileSubtypeId = def.Id.SubtypeName;
var targetBytes = MyAPIGateway.Utilities.SerializeToBinary <ActionProfile>(actionObject);
//Logger.WriteLog("Action Profile Added: " + def.Id.SubtypeName);
ActionObjectTemplates.Add(def.Id.SubtypeName, targetBytes);
continue;
}
if (def.DescriptionText.Contains("[RivalAI Condition]") == true && ChatObjectTemplates.ContainsKey(def.Id.SubtypeName) == false)
{
var conditionObject = new ConditionProfile();
conditionObject.InitTags(def.DescriptionText);
conditionObject.ProfileSubtypeId = def.Id.SubtypeName;
var conditionBytes = MyAPIGateway.Utilities.SerializeToBinary <ConditionProfile>(conditionObject);
//Logger.WriteLog("Condition Profile Added: " + def.Id.SubtypeName);
ConditionObjectTemplates.Add(def.Id.SubtypeName, conditionBytes);
continue;
}
if (def.DescriptionText.Contains("[RivalAI Target]") == true && TargetObjectTemplates.ContainsKey(def.Id.SubtypeName) == false)
{
var targetObject = new TargetProfile();
targetObject.InitTags(def.DescriptionText);
targetObject.ProfileSubtypeId = def.Id.SubtypeName;
var targetBytes = MyAPIGateway.Utilities.SerializeToBinary <TargetProfile>(targetObject);
//Logger.WriteLog("Target Profile Added: " + def.Id.SubtypeName);
TargetObjectTemplates.Add(def.Id.SubtypeName, targetBytes);
continue;
}
} catch (Exception e) {
Logger.WriteLog(string.Format("Caught Error While Processing Definition {0}", def.Id));
Logger.WriteLog(e.ToString());
}
}
//Get All Triggers - Build With Action, Chat and Spawner
foreach (var def in definitionList)
{
if (string.IsNullOrWhiteSpace(def.DescriptionText) == true)
{
continue;
}
if (def.DescriptionText.Contains("[RivalAI Trigger]") == true && TriggerObjectTemplates.ContainsKey(def.Id.SubtypeName) == false)
{
var triggerObject = new TriggerProfile();
triggerObject.InitTags(def.DescriptionText);
triggerObject.ProfileSubtypeId = def.Id.SubtypeName;
var triggerBytes = MyAPIGateway.Utilities.SerializeToBinary <TriggerProfile>(triggerObject);
//Logger.WriteLog("Trigger Profile Added: " + def.Id.SubtypeName);
TriggerObjectTemplates.Add(def.Id.SubtypeName, triggerBytes);
continue;
}
}
//Get All TriggerGroups, Autopilot
foreach (var def in definitionList)
{
if (string.IsNullOrWhiteSpace(def.DescriptionText) == true)
{
continue;
}
if (def.DescriptionText.Contains("[RivalAI Autopilot]") == true && AutopilotObjectTemplates.ContainsKey(def.Id.SubtypeName) == false)
{
var autopilotObject = new AutoPilotProfile();
autopilotObject.InitTags(def.DescriptionText);
autopilotObject.ProfileSubtypeId = def.Id.SubtypeName;
var autopilotBytes = MyAPIGateway.Utilities.SerializeToBinary <AutoPilotProfile>(autopilotObject);
//Logger.WriteLog("Trigger Profile Added: " + def.Id.SubtypeName);
AutopilotObjectTemplates.Add(def.Id.SubtypeName, autopilotBytes);
continue;
}
if (def.DescriptionText.Contains("[RivalAI TriggerGroup]") == true && TriggerObjectTemplates.ContainsKey(def.Id.SubtypeName) == false)
{
var triggerObject = new TriggerGroupProfile();
triggerObject.InitTags(def.DescriptionText);
triggerObject.ProfileSubtypeId = def.Id.SubtypeName;
var triggerBytes = MyAPIGateway.Utilities.SerializeToBinary <TriggerGroupProfile>(triggerObject);
//Logger.WriteLog("Trigger Profile Added: " + def.Id.SubtypeName);
TriggerGroupObjectTemplates.Add(def.Id.SubtypeName, triggerBytes);
continue;
}
}
//Get All Behavior
foreach (var def in definitionList)
{
if (string.IsNullOrWhiteSpace(def.DescriptionText))
{
continue;
}
if ((def.DescriptionText.Contains("[RivalAI Behavior]") || def.DescriptionText.Contains("[Rival AI Behavior]")) && BehaviorTemplates.ContainsKey(def.Id.SubtypeName) == false)
{
BehaviorTemplates.Add(def.Id.SubtypeName, def.DescriptionText);
continue;
}
}
//Print Profile Names To Log:
BuildKeyListAndWriteToLog("Behavior", BehaviorTemplates.Keys);
BuildKeyListAndWriteToLog("Autopilot", AutopilotObjectTemplates.Keys);
BuildKeyListAndWriteToLog("Trigger", TriggerObjectTemplates.Keys);
BuildKeyListAndWriteToLog("TriggerGroup", TriggerGroupObjectTemplates.Keys);
BuildKeyListAndWriteToLog("Condition", ConditionObjectTemplates.Keys);
BuildKeyListAndWriteToLog("Action", ActionObjectTemplates.Keys);
BuildKeyListAndWriteToLog("Chat", ChatObjectTemplates.Keys);
BuildKeyListAndWriteToLog("Spawn", SpawnerObjectTemplates.Keys);
BuildKeyListAndWriteToLog("Target", TargetObjectTemplates.Keys);
}
public void TestWithMovingMarkers()
{
double dPhi = 4;
double Phi = 40;
double phi = 0;
string name = Path.Combine(this.GetType().Name, $"Moving");
do
{
var test = new TestDescription(MethodBase.GetCurrentMethod().Name, name);
ImageGenerator generator = new ImageGenerator(test.Name);
Marker vAncor = new Marker()
{
Center = ImageGenerator.DefaultCentre,
Diameter = 60,
Fill = Colors.Green,
Border = Colors.Gray
};
generator.AddMarkerToImage(vAncor);
var xDelta = ImageGenerator.DefaultRadius * Math.Sin(Extensions.ConvertToRadians(phi));
var yDelta = ImageGenerator.DefaultRadius * Math.Cos(Extensions.ConvertToRadians(phi));
var delta = new Vector(xDelta, yDelta);
Marker vTip = new Marker()
{
Center = ImageGenerator.DefaultCentre + delta,
Diameter = 100,
Fill = Colors.Blue,
Border = Colors.Gray
};
generator.AddMarkerToImage(vTip);
var img = generator.RenderImage();
TestImageHelper.SaveBitmap(test.FileName_Image, img);
var sut = new MarkerScanner(Sink.PromptNewMessage_Handler, Sink.OnAnchorSetEvent, Sink.OnMovingTipSetEvent);
var aProfile = new TargetProfile()
{
Centre = new BlobCentre(vAncor.Center, 0), Color = Extensions.SetColor(vAncor.Fill)
};
var mtProfile = new TargetProfile()
{
Centre = new BlobCentre(vTip.Center, 0), Color = Extensions.SetColor(vTip.Fill)
};
Sink.MyLog.Clear();
Sink.ResetPoints();
sut.TryToSetAnchor(img, aProfile);
sut.TryToSetTip(img, mtProfile);
var pImg = sut.ProcessImage(img, 1);
TestImageHelper.SaveBitmap(test.FileName_Processed, pImg as BitmapSource);
Assert.AreEqual(vAncor.Center.X, Sink.Anchor.C.X, 2);
Assert.AreEqual(vAncor.Center.Y, Sink.Anchor.C.Y, 2);
Assert.AreEqual(vAncor.Diameter, Sink.Anchor.D, 2);
Assert.AreEqual(aProfile.Centre.X, sut.Profile.Anchor.Initial.Centre.X);
Assert.AreEqual(aProfile.Centre.Y, sut.Profile.Anchor.Initial.Centre.Y);
Assert.AreEqual(aProfile.Centre.D, sut.Profile.Anchor.Initial.Centre.D);
Assert.AreEqual(vTip.Center.X, Sink.MovingTip.C.X, 2);
Assert.AreEqual(vTip.Center.Y, Sink.MovingTip.C.Y, 2);
Assert.AreEqual(vTip.Diameter, Sink.MovingTip.D, 2);
phi = phi + dPhi;
} while (phi <= Phi);
}
public bool EvaluateTarget(ITarget target, TargetProfile data, bool skipExpensiveChecks = false)
{
if (target == null)
{
Logger.MsgDebug("Target Is Null, Cannot Evaluate", DebugTypeEnum.TargetEvaluation);
return(false);
}
if (!target.ActiveEntity())
{
Logger.MsgDebug("Target Invalid, Cannot Evaluate", DebugTypeEnum.TargetEvaluation);
return(false);
}
Logger.MsgDebug(string.Format(" - Evaluating Target: {0} using profile {1}", target.Name(), data.ProfileSubtypeId), DebugTypeEnum.TargetEvaluation);
if (!data.BuiltUniqueFilterList)
{
foreach (var filter in data.MatchAllFilters)
{
if (!data.AllUniqueFilters.Contains(filter))
{
data.AllUniqueFilters.Add(filter);
}
}
foreach (var filter in data.MatchAnyFilters)
{
if (!data.AllUniqueFilters.Contains(filter))
{
data.AllUniqueFilters.Add(filter);
}
}
foreach (var filter in data.MatchNoneFilters)
{
if (!data.AllUniqueFilters.Contains(filter))
{
data.AllUniqueFilters.Add(filter);
}
}
data.BuiltUniqueFilterList = true;
}
List <TargetFilterEnum> FilterHits = new List <TargetFilterEnum>();
//Distance
var distance = target.Distance(RemoteControl.GetPosition());
if (distance > data.MaxDistance)
{
return(false);
}
//Altitude
if (data.AllUniqueFilters.Contains(TargetFilterEnum.Altitude))
{
var altitude = target.CurrentAltitude();
if (altitude == -1000000 || (altitude >= data.MinAltitude && altitude <= data.MaxAltitude))
{
FilterHits.Add(TargetFilterEnum.Altitude);
}
Logger.MsgDebug(string.Format(" - Evaluated Altitude: {0}", altitude), DebugTypeEnum.TargetEvaluation);
}
//Broadcasting
if (data.AllUniqueFilters.Contains(TargetFilterEnum.Broadcasting))
{
var range = target.BroadcastRange(data.BroadcastOnlyAntenna);
if (range > distance || distance < data.NonBroadcastVisualRange)
{
FilterHits.Add(TargetFilterEnum.Broadcasting);
}
Logger.MsgDebug(string.Format(" - Evaluated Broadcast Range vs Distance: {0} / {1}", range, distance), DebugTypeEnum.TargetEvaluation);
}
//Faction
if (data.AllUniqueFilters.Contains(TargetFilterEnum.Faction))
{
var faction = target.FactionOwner() ?? "";
if (data.PrioritizeSpecifiedFactions || data.FactionTargets.Contains(faction))
{
FilterHits.Add(TargetFilterEnum.Faction);
}
Logger.MsgDebug(string.Format(" - Evaluated Faction: {0}", faction), DebugTypeEnum.TargetEvaluation);
}
//Gravity
if (data.AllUniqueFilters.Contains(TargetFilterEnum.Gravity))
{
var gravity = target.CurrentGravity();
if (gravity >= data.MinGravity && gravity <= data.MaxGravity)
{
FilterHits.Add(TargetFilterEnum.Gravity);
}
Logger.MsgDebug(string.Format(" - Evaluated Gravity: {0}", gravity), DebugTypeEnum.TargetEvaluation);
}
//LineOfSight
if (!skipExpensiveChecks && data.AllUniqueFilters.Contains(TargetFilterEnum.LineOfSight) && _behavior.AutoPilot.Collision.TargetResult.HasTarget())
{
bool targetMatch = (target.GetParentEntity().EntityId == _behavior.AutoPilot.Collision.TargetResult.GetCollisionEntity().EntityId);
if (targetMatch)
{
FilterHits.Add(TargetFilterEnum.MovementScore);
}
}
//MovementScore
if (data.AllUniqueFilters.Contains(TargetFilterEnum.MovementScore))
{
if (distance < data.MaxMovementDetectableDistance || data.MaxMovementDetectableDistance < 0)
{
var score = target.MovementScore();
if ((data.MinMovementScore == -1 || score >= data.MinMovementScore) && (data.MaxMovementScore == -1 || score <= data.MaxMovementScore))
{
FilterHits.Add(TargetFilterEnum.MovementScore);
}
}
}
//Name
if (data.AllUniqueFilters.Contains(TargetFilterEnum.Name))
{
var name = target.Name();
string successName = "N/A";
foreach (var allowedName in data.Names)
{
if (string.IsNullOrWhiteSpace(allowedName))
{
continue;
}
if (data.UsePartialNameMatching)
{
if (name.Contains(allowedName))
{
successName = allowedName;
break;
}
}
else
{
if (name == allowedName)
{
successName = allowedName;
break;
}
}
}
if (successName != "N/A")
{
FilterHits.Add(TargetFilterEnum.Name);
}
Logger.MsgDebug(string.Format(" - Evaluated Name: {0} // {1}", name, successName), DebugTypeEnum.TargetEvaluation);
}
//OutsideOfSafezone
if (data.AllUniqueFilters.Contains(TargetFilterEnum.OutsideOfSafezone))
{
bool inZone = target.InSafeZone();
if (!inZone)
{
FilterHits.Add(TargetFilterEnum.OutsideOfSafezone);
}
Logger.MsgDebug(string.Format(" - Evaluated Outside Safezone: {0}", !inZone), DebugTypeEnum.TargetEvaluation);
}
//Owner
if (data.AllUniqueFilters.Contains(TargetFilterEnum.Owner))
{
var owners = target.OwnerTypes(data.OnlyGetFromEntityOwner, data.GetFromMinorityGridOwners);
bool gotRelation = false;
var values = Enum.GetValues(typeof(OwnerTypeEnum)).Cast <OwnerTypeEnum>();
foreach (var ownerType in values)
{
if (ownerType == OwnerTypeEnum.None)
{
continue;
}
if (owners.HasFlag(ownerType) && data.Owners.HasFlag(ownerType))
{
gotRelation = true;
break;
}
}
if (gotRelation)
{
FilterHits.Add(TargetFilterEnum.Owner);
}
Logger.MsgDebug(string.Format(" - Evaluated Owners: Required: {0}", data.Owners.ToString()), DebugTypeEnum.TargetEvaluation);
Logger.MsgDebug(string.Format(" - Evaluated Owners: Found: {0}", owners.ToString()), DebugTypeEnum.TargetEvaluation);
Logger.MsgDebug(string.Format(" - Evaluated Target Owners: {0} / Passed: {1}", owners.ToString(), gotRelation), DebugTypeEnum.TargetEvaluation);
}
//PlayerControlled
if (data.AllUniqueFilters.Contains(TargetFilterEnum.PlayerControlled))
{
var controlled = target.PlayerControlled();
if (data.PrioritizePlayerControlled || controlled)
{
FilterHits.Add(TargetFilterEnum.PlayerControlled);
}
Logger.MsgDebug(string.Format(" - Evaluated Player Controlled: {0}", controlled), DebugTypeEnum.TargetEvaluation);
}
//PlayerKnownLocation
if (data.AllUniqueFilters.Contains(TargetFilterEnum.PlayerKnownLocation))
{
bool inKnownLocation = false;
if (MESApi.MESApiReady)
{
if (MESApi.IsPositionInKnownPlayerLocation(target.GetPosition(), true, string.IsNullOrWhiteSpace(data.PlayerKnownLocationFactionOverride) ? _behavior.Owner.Faction?.Tag : data.PlayerKnownLocationFactionOverride))
{
;
}
FilterHits.Add(TargetFilterEnum.PlayerKnownLocation);
}
Logger.MsgDebug(string.Format(" - Evaluated Player Known Location: {0}", inKnownLocation), DebugTypeEnum.TargetEvaluation);
}
//Powered
if (data.AllUniqueFilters.Contains(TargetFilterEnum.Powered))
{
bool powered = target.IsPowered();
if (powered)
{
FilterHits.Add(TargetFilterEnum.Powered);
}
Logger.MsgDebug(string.Format(" - Evaluated Power: {0}", powered), DebugTypeEnum.TargetEvaluation);
}
//Relation
if (data.AllUniqueFilters.Contains(TargetFilterEnum.Relation))
{
var relations = target.RelationTypes(RemoteControl.OwnerId, data.OnlyGetFromEntityOwner, data.GetFromMinorityGridOwners);
bool gotRelation = false;
var values = Enum.GetValues(typeof(RelationTypeEnum)).Cast <RelationTypeEnum>();
foreach (var relationType in values)
{
if (relationType == RelationTypeEnum.None)
{
continue;
}
if (relations.HasFlag(relationType) && data.Relations.HasFlag(relationType))
{
gotRelation = true;
break;
}
}
if (gotRelation)
{
FilterHits.Add(TargetFilterEnum.Relation);
}
Logger.MsgDebug(string.Format(" - Evaluated Relations: Required: {0}", data.Relations.ToString()), DebugTypeEnum.TargetEvaluation);
Logger.MsgDebug(string.Format(" - Evaluated Relations: Found: {0}", relations.ToString()), DebugTypeEnum.TargetEvaluation);
Logger.MsgDebug(string.Format(" - Evaluated Relations: {0} / Passed: {1}", relations.ToString(), gotRelation), DebugTypeEnum.TargetEvaluation);
}
//Shielded
if (data.AllUniqueFilters.Contains(TargetFilterEnum.Shielded))
{
bool shielded = target.ProtectedByShields();
if (shielded)
{
FilterHits.Add(TargetFilterEnum.Shielded);
}
Logger.MsgDebug(string.Format(" - Evaluated Shields: {0}", shielded), DebugTypeEnum.TargetEvaluation);
}
//Speed
if (data.AllUniqueFilters.Contains(TargetFilterEnum.Speed))
{
var speed = target.CurrentSpeed();
if ((data.MinSpeed < 0 || speed >= data.MinSpeed) && (data.MaxSpeed < 0 || speed <= data.MaxSpeed))
{
FilterHits.Add(TargetFilterEnum.Speed);
}
Logger.MsgDebug(string.Format(" - Evaluated Speed: {0}", speed), DebugTypeEnum.TargetEvaluation);
}
//Static
if (data.IsStatic != CheckEnum.Ignore && data.AllUniqueFilters.Contains(TargetFilterEnum.Static))
{
var staticGrid = target.IsStatic();
if ((staticGrid && data.IsStatic == CheckEnum.Yes) || (!staticGrid && data.IsStatic == CheckEnum.No))
{
FilterHits.Add(TargetFilterEnum.Static);
}
Logger.MsgDebug(string.Format(" - Evaluated Static Grid: {0}", staticGrid), DebugTypeEnum.TargetEvaluation);
}
//TargetValue
if (data.AllUniqueFilters.Contains(TargetFilterEnum.TargetValue))
{
var targetValue = target.TargetValue();
if (targetValue >= data.MinTargetValue && targetValue <= data.MaxTargetValue)
{
FilterHits.Add(TargetFilterEnum.TargetValue);
}
Logger.MsgDebug(string.Format(" - Evaluated Target Value: {0}", targetValue), DebugTypeEnum.TargetEvaluation);
}
//Underwater
if (data.AllUniqueFilters.Contains(TargetFilterEnum.Underwater))
{
bool result = false;
if (WaterHelper.Enabled)
{
result = WaterHelper.UnderwaterAndDepthCheck(target.GetPosition(), _behavior.AutoPilot.CurrentWater, true, Data.MinUnderWaterDepth, Data.MaxUnderWaterDepth);
}
if (result)
{
FilterHits.Add(TargetFilterEnum.Underwater);
}
Logger.MsgDebug(string.Format(" - Evaluated Underwater: {0}", result), DebugTypeEnum.TargetEvaluation);
}
//Any Conditions Check
bool anyConditionPassed = false;
if (data.MatchAnyFilters.Count > 0)
{
foreach (var filter in data.MatchAnyFilters)
{
if (FilterHits.Contains(filter))
{
anyConditionPassed = true;
break;
}
}
}
else
{
anyConditionPassed = true;
}
if (!anyConditionPassed)
{
Logger.MsgDebug(" - Evaluation Condition -Any- Failed", DebugTypeEnum.TargetEvaluation);
return(false);
}
//All Condition Checks
foreach (var filter in data.MatchAllFilters)
{
if (!FilterHits.Contains(filter))
{
Logger.MsgDebug(" - Evaluation Condition -All- Failed", DebugTypeEnum.TargetEvaluation);
return(false);
}
}
//None Condition Checks
foreach (var filter in data.MatchNoneFilters)
{
if (FilterHits.Contains(filter))
{
Logger.MsgDebug(" - Evaluation Condition -None- Failed", DebugTypeEnum.TargetEvaluation);
return(false);
}
}
Logger.MsgDebug(" - Evaluation Passed", DebugTypeEnum.TargetEvaluation);
TargetLastKnownCoords = target.GetPosition();
return(true);
}
private static void TransformProgram(WholeProgram wholeProgram,
string transformedBinariesPath,
string reportsPath,
MethodRemoval methodRemoval,
TargetProfile profile) {
System.IO.Directory.CreateDirectory(transformedBinariesPath);
StubMethodBodyEmitter stubEmitter = GetStubMethodBodyEmitterForProfile(profile, wholeProgram);
foreach (IAssembly assembly in wholeProgram.AllAssemblies()) {
if (AssemblyShouldBeRewritten(assembly)) {
if (assembly.PublicKeyToken.Count() > 0) {
Console.WriteLine("Warning: rewriting assembly with a public key token. {0}", assembly);
}
string outputBinary = transformedBinariesPath + @"\" + Path.GetFileName(assembly.Location);
var copy = new MetadataDeepCopier(wholeProgram.Host()).Copy(assembly);
DocumentationCommentDefinitionIdStringMap idMap = new DocumentationCommentDefinitionIdStringMap(new IAssembly[] { copy });
AssemblyReport assemblyReport = AssemblyReport.CreateAssemblyReportFromPath(copy, reportsPath, idMap);
stopwatch.Start();
RewriteBinary(copy, assemblyReport, wholeProgram.Host(), outputBinary, methodRemoval, stubEmitter);
stopwatch.Start();
}
else {
//Console.WriteLine("Skipping rewrite of of assembly {0}", assembly.Name.Value);
}
}
}
private static StubMethodBodyEmitter GetStubMethodBodyEmitterForProfile(TargetProfile profile, WholeProgram wholeProgram) {
StubMethodBodyEmitter emitter;
switch (profile) {
case TargetProfile.Desktop:
emitter = new DotNetDesktopStubMethodBodyEmitter(wholeProgram.Host());
break;
case TargetProfile.Phone:
emitter = new WindowsPhoneStubMethodBodyEmitter(wholeProgram.Host());
break;
default:
emitter = new DotNetDesktopStubMethodBodyEmitter(wholeProgram.Host());
break;
}
return emitter;
}
private static RapidTypeAnalysis RunRTA(WholeProgram wholeProgram,
IEnumerable<ILGarbageCollect.Summaries.IMethodSummarizer> reflectionSummarizers,
IEnumerable<IMethodReference> entryPoints,
string reportPath,
TargetProfile profile) {
var rta = new RapidTypeAnalysis(wholeProgram, profile);
rta.ReflectionSummarizers = reflectionSummarizers;
Console.WriteLine("Running Rapid Type Analysis with {0} entry points", entryPoints.Count());
rta.Run(entryPoints);
stopwatch.Stop();
OutputRTAStatistics(rta, reportPath);
return rta;
}
public DynamicProfile(TargetProfile profile)
{
Initial = (TargetProfile)profile.Clone();
Current = profile;
Last = (TargetProfile)profile.Clone();
}
public ITarget GetTargetFromSorting(List <ITarget> targets, TargetProfile data)
{
//List Empty, you get null soup!
if (targets.Count == 0)
{
return(null);
}
//Only 1 thing in list, therefore you get the 1 thing
if (targets.Count == 1)
{
return(targets[0]);
}
//Random - may RNGesus be generous
if (data.GetTargetBy == TargetSortEnum.Random)
{
return(targets[Utilities.Rnd.Next(0, targets.Count)]);
}
if (data.GetTargetBy == TargetSortEnum.ClosestDistance)
{
int index = -1;
double dist = -1;
for (int i = 0; i < targets.Count; i++)
{
var thisDist = targets[i].Distance(RemoteControl.GetPosition());
if (index == -1 || thisDist < dist)
{
dist = thisDist;
index = i;
}
}
return(targets[index]);
}
if (data.GetTargetBy == TargetSortEnum.FurthestDistance)
{
int index = -1;
double dist = -1;
for (int i = 0; i < targets.Count; i++)
{
var thisDist = targets[i].Distance(RemoteControl.GetPosition());
if (index == -1 || thisDist > dist)
{
dist = thisDist;
index = i;
}
}
return(targets[index]);
}
if (data.GetTargetBy == TargetSortEnum.HighestTargetValue)
{
int index = -1;
float targetValue = -1;
for (int i = 0; i < targets.Count; i++)
{
var thisValue = targets[i].TargetValue();
if (index == -1 || thisValue > targetValue)
{
targetValue = thisValue;
index = i;
}
}
return(targets[index]);
}
if (data.GetTargetBy == TargetSortEnum.LowestTargetValue)
{
int index = -1;
float targetValue = -1;
for (int i = 0; i < targets.Count; i++)
{
var thisValue = targets[i].TargetValue();
if (index == -1 || thisValue < targetValue)
{
targetValue = thisValue;
index = i;
}
}
return(targets[index]);
}
return(null);
}
