internal static void Reachable(
IMetadataHost host,
ISlice<MethodReferenceAdaptor, FieldReferenceAdaptor, TypeReferenceAdaptor, IAssemblyReference> slice,
HashSet<object> thingsToKeep,
HashSet<uint> methodsWhoseBodiesShouldBeKept,
out Dictionary<IMethodDefinition, uint> contractOffsets
) {
Contract.Requires(host != null);
Contract.Requires(slice != null);
Contract.Requires(thingsToKeep != null);
Contract.Requires(methodsWhoseBodiesShouldBeKept != null);
var traverser = new MetadataTraverser();
var me = new FindReachable(host, traverser, slice, thingsToKeep, methodsWhoseBodiesShouldBeKept);
traverser.TraverseIntoMethodBodies = true;
traverser.PreorderVisitor = me;
var methodsToTraverse = slice.Methods;
foreach (var m in methodsToTraverse) {
var methodDefinition = m.reference.ResolvedMethod;
traverser.Traverse(methodDefinition);
}
foreach (var c in slice.Chains) {
VisitChain(c, traverser);
}
contractOffsets = me.contractOffsets;
return;
}
internal static void Reachable(
IMetadataHost host,
ISlice <MethodReferenceAdaptor, FieldReferenceAdaptor, TypeReferenceAdaptor, IAssemblyReference> slice,
HashSet <object> thingsToKeep,
HashSet <uint> methodsWhoseBodiesShouldBeKept,
out Dictionary <IMethodDefinition, uint> contractOffsets
)
{
Contract.Requires(host != null);
Contract.Requires(slice != null);
Contract.Requires(thingsToKeep != null);
Contract.Requires(methodsWhoseBodiesShouldBeKept != null);
var traverser = new MetadataTraverser();
var me = new FindReachable(host, traverser, slice, thingsToKeep, methodsWhoseBodiesShouldBeKept);
traverser.TraverseIntoMethodBodies = true;
traverser.PreorderVisitor = me;
var methodsToTraverse = slice.Methods;
foreach (var m in methodsToTraverse)
{
var methodDefinition = m.reference.ResolvedMethod;
traverser.Traverse(methodDefinition);
}
foreach (var c in slice.Chains)
{
VisitChain(c, traverser);
}
contractOffsets = me.contractOffsets;
return;
}
protected override void UpdateView(IUnit unit, ISlice slice, float deltaTime)
{
if (slice is IProperty prop)
{
UpdateValue(prop);
}
}
T ICoreInstantiate.Instantiate <T>()
{
ISlice slice = (ISlice)System.Activator.CreateInstance(GetType());
slice.FillFrom(this);
return((T)slice);
}
public override void FillFrom(ISlice other)
{
if (other is BaseProperty <T> prop)
{
m_Absorbs = new List <IDamage>(prop.m_Absorbs);
m_Resists = new List <IDamage>(prop.m_Resists);
}
}
public override void FillFrom(ISlice other)
{
if (other is DamageFire @base)
{
m_ViewPrefab = @base.m_ViewPrefab;
m_Damages = new List <IDamage>(@base.m_Damages);
}
}
public void QueueSlice(ISlice slice)
{
if (slice == null)
{
return;
}
slice.TimeQueuedMs = _timeStamp;
_sliceQueue.Add(slice);
}
public override void FillFrom(ISlice other)
{
base.FillFrom(other);
if (other is Health health)
{
m_Value = health.m_Value;
m_Regen = health.m_Regen;
m_RegenDuration = health.m_RegenDuration;
}
}
public override void FillFrom(ISlice other)
{
base.FillFrom(other);
if (other is Shooting shooting)
{
m_TargetterPrefab = shooting.m_TargetterPrefab;
m_SearchRate = shooting.m_SearchRate;
m_EffectRate = shooting.m_EffectRate;
}
}
public override void FillFrom(ISlice other)
{
base.FillFrom(other);
if (other is Shield shield)
{
m_Value = shield.m_Value;
m_RegenRate = shield.m_RegenRate;
m_StaggerDuration = shield.m_StaggerDuration;
}
}
static internal void SetAll(ref _Recons st, ISlice <string> rec)
{
st.Dienq = rec[0];
st.Phuan = rec[1];
st.Karlgren = rec[2];
st.Hvang = rec[3];
st.Lyx = rec[4];
st.Zjew = rec[5];
st.PulleyBlank = rec[6];
}
protected override void UpdateView(IUnit unit, ISlice slice, float deltaTime)
{
//Poolable.TryGetPoolable<ICoreGameObjectInstantiate>(gameObject).GameObject;
if (unit.Turret != null)
{
transform.localRotation = unit.Turret.GameObject.transform.localRotation;
}
var system = GetComponent <ParticleSystem>();
system.Play(true);
}
public void RotatingAndRotatingBackBringsBackToStartPoint()
{
ISlice _slice = new Slice(_basicBlocks);
ISlice newSlice = _slice.rotate(Direction.left).rotate(Direction.right);
Assert.AreEqual(newSlice.get_block_in_position(0, 0).get_colour_in_axis(Axis.x), Colour.Blue);
Assert.AreEqual(newSlice.get_block_in_position(0, 1).get_colour_in_axis(Axis.x), Colour.Red);
Assert.AreEqual(newSlice.get_block_in_position(0, 2).get_colour_in_axis(Axis.x), Colour.White);
Assert.AreEqual(newSlice.get_block_in_position(1, 0).get_colour_in_axis(Axis.x), Colour.Green);
Assert.AreEqual(newSlice.get_block_in_position(1, 1).get_colour_in_axis(Axis.x), Colour.Orange);
}
public override void FillFrom(ISlice other)
{
base.FillFrom(other);
if (other is Moving)
{
var moving = (other as Moving);
moveSpeed = moving.moveSpeed;
rotateSpeed = moving.rotateSpeed;
pointToPointThreshold = moving.pointToPointThreshold;
m_Path = moving.m_Path;
}
}
public override bool Equals(object?obj)
{
return(obj switch
{
NilType _ => true,
ISlice slice => slice == Default,
IArray array => array == Default,
IChannel channel => channel == Default,
@string gostr => gostr == Default,
string str => str == Default,
_ => obj is null
});
public void ConnectWith <TAxon>(ISlice <T> nextSlice) where TAxon : IAxon <T>, new()
{
foreach (var fromNeuron in Neurons)
{
foreach (var toNeuron in nextSlice.Neurons)
{
var axon = new TAxon
{
InputNeuron = fromNeuron
};
toNeuron.InputAxons.Add(axon);
}
}
}
public Task Run(ISlice slice)
{
if (!Idle)
{
return(null);
}
_slice = slice;
_cancelSource.CancelAfter(ConfigManager.Properties.BackgroundThreadTimeout);
var token = _cancelSource.Token;
//TODO : Fix cancelation
var task = Task.Run(() => Start(token));//, token);
Idle = false;
return(task);
}
private bool MakeSureSliceHasAtLeastMethodSourceLocation(ISlice <MethodReferenceAdaptor, FieldReferenceAdaptor, TypeReferenceAdaptor, IAssemblyReference> slice, ISourceLocationProvider sourceLocationProvider)
{
Contract.Requires(slice != null);
Contract.Requires(sourceLocationProvider != null);
foreach (var m in slice.Methods)
{
var methodDefinition = m.reference.ResolvedMethod;
if (sourceLocationProvider.GetPrimarySourceLocationsFor(methodDefinition.Locations).Any())
{
return(true);
}
}
return(false);
}
protected override void UpdateView(IUnit unit, ISlice slice, float deltaTime)
{
if (unit.Turret != null)
{
transform.localRotation = unit.Turret.GameObject.transform.localRotation;
}
var system = GetComponent <ParticleSystem>();
system.Play(true);
StartCoroutine(WaitStop());
IEnumerator WaitStop()
{
yield return(new WaitForSeconds(5));
system.Stop();
}
}
private void GenerateSlice()
{
CurrentSlice.Clear();
foreach (Transform child in _startCircle.transform)
{
Destroy(child.gameObject);
}
float usefulWeight = 0f;
float randomResult = Random.Range(0, weigths.Sum(w => w));
int amountOfSlicesToSpawn = 0;
for (int i = 0; i < weigths.Count; i++)
{
if (randomResult <= weigths[i] + usefulWeight)
{
amountOfSlicesToSpawn = i + 1;
break;
}
usefulWeight += weigths[i];
}
if (amountOfSlicesToSpawn == 0)
{
Debug.Log("Generator generated nothing");
amountOfSlicesToSpawn = 1;
}
int startingPosition = Random.Range(0, 6);
for (int i = 0; i < amountOfSlicesToSpawn; i++)
{
GameObject newSlice = Instantiate(_slicePrefab, _startCircle.transform);
ISlice sliceComponent = newSlice.GetComponent <ISlice>();
sliceComponent.Init(startingPosition + i > 5 ? (Position)(startingPosition + i - 6) : (Position)(startingPosition + i));
CurrentSlice.Add(sliceComponent);
}
if (IsGameOver())
{
EventsManager.Broadcast(EventsType.GameOver);
}
}
private FindReachable(
IMetadataHost host,
MetadataTraverser myTraverser, ISlice <MethodReferenceAdaptor, FieldReferenceAdaptor, TypeReferenceAdaptor, IAssemblyReference> slice,
HashSet <object> thingsToKeep,
HashSet <uint> methodsWhoseBodiesShouldBeKept
)
{
Contract.Requires(host != null);
Contract.Requires(myTraverser != null);
Contract.Requires(slice != null);
Contract.Requires(thingsToKeep != null);
Contract.Requires(methodsWhoseBodiesShouldBeKept != null);
this.host = host;
this.traverser = myTraverser;
this.unitIdentity = slice.ContainingAssembly.UnitIdentity;
this.slice = slice;
this.thingsToKeep = thingsToKeep;
this.methodsWhoseBodiesShouldBeKept = methodsWhoseBodiesShouldBeKept;
this.contractOffsets = new Dictionary <IMethodDefinition, uint>();
}
private FindReachable(
IMetadataHost host,
MetadataTraverser myTraverser, ISlice<MethodReferenceAdaptor, FieldReferenceAdaptor, TypeReferenceAdaptor, IAssemblyReference> slice,
HashSet<object> thingsToKeep,
HashSet<uint> methodsWhoseBodiesShouldBeKept
) {
Contract.Requires(host != null);
Contract.Requires(myTraverser != null);
Contract.Requires(slice != null);
Contract.Requires(thingsToKeep != null);
Contract.Requires(methodsWhoseBodiesShouldBeKept != null);
this.host = host;
this.traverser = myTraverser;
this.unitIdentity = slice.ContainingAssembly.UnitIdentity;
this.slice = slice;
this.thingsToKeep = thingsToKeep;
this.methodsWhoseBodiesShouldBeKept = methodsWhoseBodiesShouldBeKept;
this.contractOffsets = new Dictionary<IMethodDefinition, uint>();
}
void ISliceVisualizer.UpdateView(IUnit unit, ISlice slice, float deltaTime)
{
UpdateView(unit, slice, deltaTime);
}
public static void DoSomethingCoolWithTheSliceSlide(ISlice slice)
{
slice.Slide.LookitMeIAmLearningDesignPatterns();
}
public static Assembly PruneAssembly(HostEnvironment host, ISlice<MethodReferenceAdaptor, FieldReferenceAdaptor, TypeReferenceAdaptor, IAssemblyReference> slice) {
Contract.Requires(host != null);
Contract.Requires(slice != null);
var newAssemblyName = slice.Name;
var originalAssembly = slice.ContainingAssembly.ResolvedAssembly;
Contract.Assume(!(originalAssembly is Dummy));
var methodDefsToKeep = new HashSet<uint>();
foreach (var m in slice.Methods) {
methodDefsToKeep.Add(m.reference.InternedKey);
}
var copier = new MetadataDeepCopier(host);
var thingsToKeep = new HashSet<object>();
var methodHashAttributes = new Dictionary<IMethodDefinition, MethodHashAttribute>();
var me = new Prune(host, copier, thingsToKeep, methodDefsToKeep, methodHashAttributes);
// 1. everything that is specified in the slice should definitely be kept.
foreach (var c in slice.Chains) {
me.VisitChain(c);
}
// 2. everything reachable from the initial set of things to keep should be kept
Dictionary<IMethodDefinition, uint> contractOffsets;
FindReachable.Reachable(host, slice, thingsToKeep, methodDefsToKeep, out contractOffsets);
me.contractOffsets = contractOffsets;
// 3. copy the original assembly --- entirely!
var a_prime = copier.Copy(originalAssembly);
var nameTable = host.NameTable;
a_prime.ModuleName = nameTable.GetNameFor(newAssemblyName + ".dll");
a_prime.Name = nameTable.GetNameFor(newAssemblyName);
var mutableRoot = (RootUnitNamespace)(a_prime.UnitNamespaceRoot);
var methodHashAttributeType = DefineMethodHashAttributeType(host, mutableRoot);
me.methodHashAttributeCtor = new Microsoft.Cci.MethodReference(
host,
methodHashAttributeType,
CallingConvention.HasThis,
host.PlatformType.SystemVoid,
host.NameTable.Ctor,
0,
me.systemString,
me.systemInt);
// 4. delete all unwanted things from the mutable copy
me.RewriteChildren(a_prime);
var remainingTypes = new List<INamedTypeDefinition>(a_prime.AllTypes.Count); // will only shrink
remainingTypes.Add(a_prime.AllTypes[0]); // <Module> class is always kept
for (int i = 1, n = a_prime.AllTypes.Count; i < n; i++) {
var t = a_prime.AllTypes[i];
Contract.Assume(t!= null);
Contract.Assume(copier.OriginalFor.ContainsKey(t));
var orig = copier.OriginalFor[t];
if (thingsToKeep.Contains(orig))
remainingTypes.Add(t);
}
a_prime.AllTypes = remainingTypes;
// do this afterwards so it doesn't get visited.
mutableRoot.Members.Add(methodHashAttributeType);
a_prime.AllTypes.Add(methodHashAttributeType);
return a_prime;
}
internal void AddIndex(ISlice slice)
{
npy_intp step;
bool negativeStep;
npy_intp start;
npy_intp stop;
bool hasStop;
// Find the step
if (slice.Step == null)
{
step = (npy_intp)1;
negativeStep = false;
}
else
{
step = ConvertSliceValue(slice.Step);
negativeStep = (step < 0);
}
// Find the start
if (slice.Start == null)
{
start = (npy_intp)(negativeStep ? -1 : 0);
}
else
{
start = ConvertSliceValue(slice.Start);
}
// Find the stop
if (slice.Stop == null)
{
hasStop = false;
stop = 0;
}
else
{
hasStop = true;
stop = ConvertSliceValue(slice.Stop);
}
// Write the type
int offset = num_indexes * sizeof(npy_intp);
if (!hasStop)
{
indexes[num_indexes].type = NpyIndexType.NPY_INDEX_SLICE_NOSTOP;
NpyIndexSliceNoStop IndexSliceNoStop = new NpyIndexSliceNoStop()
{
start = start,
step = step,
};
indexes[num_indexes].slice_nostop = IndexSliceNoStop;
}
else
{
indexes[num_indexes].type = NpyIndexType.NPY_INDEX_SLICE;
NpyIndexSlice IndexSlice = new NpyIndexSlice()
{
start = start,
stop = stop,
step = step,
};
indexes[num_indexes].slice = IndexSlice;
}
++num_indexes;
}
public ICube replace_slice(SliceIdentifier identifier, ISlice slice)
{
throw new NotImplementedException();
}
public static string CreateFilter(ISlice filter)
{
var visitor = new RenderFilterVisitor();
filter.Accept(visitor);
return visitor.Html;
}
static public AdaptorSlice <T, U> Cast <T, U> (this ISlice <T> slice, Func <T, U> adaptor)
{
return(new AdaptorSlice <T, U>(slice, adaptor));
}
public AdaptorSlice(ISlice <T> slice, Func <T, U> adaptor)
{
_slice = slice;
_adaptor = adaptor;
}
protected override void FillFrom(ISlice other)
{
}
public abstract void FillFrom(ISlice other);
public static Assembly PruneAssembly(HostEnvironment host, ISlice <MethodReferenceAdaptor, FieldReferenceAdaptor, TypeReferenceAdaptor, IAssemblyReference> slice)
{
Contract.Requires(host != null);
Contract.Requires(slice != null);
var newAssemblyName = slice.Name;
var originalAssembly = slice.ContainingAssembly.ResolvedAssembly;
Contract.Assume(!(originalAssembly is Dummy));
var methodDefsToKeep = new HashSet <uint>();
foreach (var m in slice.Methods)
{
methodDefsToKeep.Add(m.reference.InternedKey);
}
var copier = new MetadataDeepCopier(host);
var thingsToKeep = new HashSet <object>();
var methodHashAttributes = new Dictionary <IMethodDefinition, MethodHashAttribute>();
var me = new Prune(host, copier, thingsToKeep, methodDefsToKeep, methodHashAttributes);
// 1. everything that is specified in the slice should definitely be kept.
foreach (var c in slice.Chains)
{
me.VisitChain(c);
}
// 2. everything reachable from the initial set of things to keep should be kept
Dictionary <IMethodDefinition, uint> contractOffsets;
FindReachable.Reachable(host, slice, thingsToKeep, methodDefsToKeep, out contractOffsets);
me.contractOffsets = contractOffsets;
// 3. copy the original assembly --- entirely!
var a_prime = copier.Copy(originalAssembly);
var nameTable = host.NameTable;
a_prime.ModuleName = nameTable.GetNameFor(newAssemblyName + ".dll");
a_prime.Name = nameTable.GetNameFor(newAssemblyName);
var mutableRoot = (RootUnitNamespace)(a_prime.UnitNamespaceRoot);
var methodHashAttributeType = DefineMethodHashAttributeType(host, mutableRoot);
me.methodHashAttributeCtor = new Microsoft.Cci.MethodReference(
host,
methodHashAttributeType,
CallingConvention.HasThis,
host.PlatformType.SystemVoid,
host.NameTable.Ctor,
0,
me.systemString,
me.systemInt);
// 4. delete all unwanted things from the mutable copy
me.RewriteChildren(a_prime);
var remainingTypes = new List <INamedTypeDefinition>(a_prime.AllTypes.Count); // will only shrink
remainingTypes.Add(a_prime.AllTypes[0]); // <Module> class is always kept
for (int i = 1, n = a_prime.AllTypes.Count; i < n; i++)
{
var t = a_prime.AllTypes[i];
Contract.Assume(t != null);
Contract.Assume(copier.OriginalFor.ContainsKey(t));
var orig = copier.OriginalFor[t];
if (thingsToKeep.Contains(orig))
{
remainingTypes.Add(t);
}
}
a_prime.AllTypes = remainingTypes;
// do this afterwards so it doesn't get visited.
mutableRoot.Members.Add(methodHashAttributeType);
a_prime.AllTypes.Add(methodHashAttributeType);
return(a_prime);
}
protected abstract void UpdateView(IUnit unit, ISlice slice, float deltaTime);
public bool WriteSliceToFile(ISlice <MethodReferenceAdaptor, FieldReferenceAdaptor, TypeReferenceAdaptor, IAssemblyReference> slice, string directory, out string dll)
{
#if TRACE_PERFORMANCE
var stopWatch = new Stopwatch();
stopWatch.Start();
#endif
var newAssembly = Prune.PruneAssembly(host, slice);
#if TRACE_PERFORMANCE
Console.WriteLine("Time to prune the assembly: {0}", stopWatch.Elapsed);
#endif
var errors = ValidateAssembly(host, newAssembly);
if (/*errors != null && */ 0 < errors.Count)
{
#if !DEBUG_SLICE
dll = null;
return(false);
#endif
}
//Get a PDB reader if there is a PDB file.
PdbReader /*?*/ pdbReader = null;
string pdbFile = slice.ContainingAssembly.ResolvedAssembly.DebugInformationLocation;
if (string.IsNullOrEmpty(pdbFile) || !File.Exists(pdbFile))
{
pdbFile = Path.ChangeExtension(slice.ContainingAssembly.ResolvedAssembly.Location, "pdb");
}
if (File.Exists(pdbFile))
{
using (var pdbStream = File.OpenRead(pdbFile)) {
pdbReader = new PdbReader(pdbStream, host);
}
}
using (pdbReader) {
ISourceLocationProvider sourceLocationProvider = pdbReader;
ILocalScopeProvider localScopeProvider = pdbReader;
Contract.Assume(sourceLocationProvider != null, "why??");
if (!MakeSureSliceHasAtLeastMethodSourceLocation(slice, sourceLocationProvider))
{
dll = null;
return(false);
}
dll = Path.Combine(directory, slice.Name + ".dll");
#if TRACE_PERFORMANCE
stopWatch.Reset();
#endif
using (var peStream = File.Create(dll)) {
if (pdbReader == null)
{
PeWriter.WritePeToStream(newAssembly, host, peStream);
}
else
{
using (var pdbWriter = new PdbWriter(dll.Replace(".dll", ".pdb"), pdbReader, emitTokenSourceInfo: true)) {
PeWriter.WritePeToStream(newAssembly, host, peStream, sourceLocationProvider, localScopeProvider, pdbWriter);
}
}
}
#if TRACE_PERFORMANCE
Console.WriteLine("Time spent to write on the disk: {0}", stopWatch.Elapsed);
#endif
}
#if !DEBUG_SLICE
if (errors != null && 0 < errors.Count)
{
using (var tw = new StreamWriter(File.Create(Path.Combine(directory, slice.Name + ".errors.txt"))))
{
// something is performed asynchronously and may not be terminated here, that is wrong!
lock (errors)
{
foreach (var err in errors)
{
tw.WriteLine(err.Location);
foreach (var e in err.Errors)
{
tw.WriteLine("{0} {1} {2}", e.IsWarning ? "WARNING" : "ERROR ", e.Code, e.Message);
}
tw.WriteLine();
}
}
}
return(false);
}
#endif
// Can this be checked before writing it out?
if (newAssembly.AssemblyReferences.Any(ar => ar.AssemblyIdentity.Equals(slice.ContainingAssembly.AssemblyIdentity)))
{
}
return(true);
}
