public void MemorizerTest()
{
var times = Enumerable.Range(1, 4).Select(i =>
{
Memorizer <double, double, double> mem = new Memorizer <double, double, double>(d => modf(d, Math.PI), Math.Sin);
var timer = Stopwatch.StartNew();
var output = Enumerable.Range(0, (int)Math.Pow(3, i))
.Select(i2 => i2 / 20.0)
.Select(mem.Invoke).ToList();
return(timer.Elapsed);
}).ToList();
var times2 = Enumerable.Range(1, 4).Select(i =>
{
//Memorizer<double, double, double> mem = new Memorizer<double, double, double>(d => modf(d, Math.PI), Math.Sin);
var timer = Stopwatch.StartNew();
var output = Enumerable.Range(0, (int)Math.Pow(3, i))
.Select(i2 => i2 / 20.0)
.Select(Math.Sin).ToList();
return(timer.Elapsed);
}).ToList();
Debug.WriteLine(times);
Debug.WriteLine(times2);
}
private void Start()
{
StartCoroutine(Lost());
_animator = transform.GetComponent <Animator>();
_rigidbody2D = transform.GetComponent <Rigidbody2D>();
_memorizer = GameObject.Find("Memorizer").GetComponent <Memorizer>();
}
public void MemorizerThreadTest()
{
List <Task> tasks = new List <Task>();
// Testing a very short operation in the memorizer
// With a relatively short running tasks to test if we can break the internals of the memorizer.
var numberThingTest = new Memorizer <int, int>(thing => thing % 25)
{
MaxNumberOfElements = 25, SoftSizeDecayTime = TimeSpan.MaxValue
};
var numberRevertThingTest = new Memorizer <int, int>(thing => - thing)
{
MaxNumberOfElements = 25, SoftSizeDecayTime = TimeSpan.MaxValue
};
for (int i = 0; i < 10; i++)
{
int _i = i;
tasks.Add(Task.Factory.StartNew(() =>
{
for (int j = 0; j < 1000; j++)
{
var value1 = numberThingTest.Invoke((_i + j) % 71); // ensure collision of keys.
var value2 = numberRevertThingTest.Invoke(value1);
Assert.IsTrue(value2 == -(((_i + j) % 71) % 25)); // check calculation.
}
}));
}
Task.WhenAll(tasks).Wait();
Task.WaitAll(tasks.ToArray());
}
private void Awake()
{
_controller = GetComponent <CharacterController2D>();
_playerInfo = GetComponent <PlayerInfo>();
InAim = false;
_animator = GetComponent <Animator>();
_memorizer = GameObject.Find("Memorizer").GetComponent <Memorizer>();
}
public void ShouldHandlFetchCmd(string cmdText, bool isValid, int numResponses)
{
Memorizer.Tell(new MessageMemorizerActor.Message("foo1", DateTime.UtcNow, "any"));
Memorizer.Tell(new MessageMemorizerActor.Message("foo2", DateTime.UtcNow.AddMinutes(1), "any"));
Memorizer.Tell(new MessageMemorizerActor.Message("foo3", DateTime.UtcNow.AddMinutes(5), "any"));
Memorizer.Tell(new MessageMemorizerActor.Message("foo4", DateTime.UtcNow.AddHours(1), "any"));
Memorizer.Tell(new MessageMemorizerActor.Message("foo5", DateTime.UtcNow.AddDays(1), "any"));
ReceiveN(5);
}
public TapAssemblyResolver(IEnumerable <string> directoriesToSearch)
{
FileFinder.DirectoriesToSearch = directoriesToSearch;
assemblyResolutionMemorizer = new Memorizer <resolveKey, Assembly>(key => resolveAssembly(key.Name, key.ReflectionOnly))
{
MaxNumberOfElements = 10000,
CylicInvokeResponse = Memorizer.CyclicInvokeMode.ReturnDefaultValue
};
}
public void StartRecording()
{
ClearCharacters();
DirectoryInfo dirInfo = new DirectoryInfo(Application.dataPath + "/" + GameManager.Instance.DanceFilePath);
_memorizeCharacter = Instantiate(_memorizeCharPrefab).GetComponent <Memorizer>();
_memorizeCharacter.transform.position = _memCharPos;
UIManager.Instance.SwitchState(UIManager.Instance.RecordUiState);
}
public RadioModel()
{
AvailableRadio = Radio <G313Radio> .Find <G313RadioInfoProvider>().List().ToArray();
Limits = new G313RadioLimits(null);
Settings = SettingsModel.LoadOrCreate();
Settings.Initialize();
Memory = Memorizer.LoadOrCreate();
Debug = new DebugModel(null);
}
private void Start()
{
var player = GameObject.FindGameObjectWithTag("Player");
_playerInfo = player.GetComponent <PlayerInfo>();
_playerController2D = player.GetComponent <CharacterController2D>();
_playerMove = player.GetComponent <PlayerMove>();
_memorizer = GameObject.Find("Memorizer").GetComponent <Memorizer>();
_fade = GameObject.Find("Fade").GetComponent <CanvasGroup>();
_dialog = GameObject.Find("Dialog Tip Box").transform;
_digGroup = _dialog.GetComponent <CanvasGroup>();
}
public void Awake()
{
_memorizer = GameObject.Find("Memorizer").GetComponent <Memorizer>();
if (_binding)
{
Instantiate(_memorizer.GetActor().transform, transform.position, transform.localRotation, transform);
}
else
{
Instantiate(_memorizer.GetActor().transform, transform.position, transform.localRotation);
}
}
private void Start()
{
var player = GameObject.FindGameObjectWithTag("Player").transform;
_controller = player.GetComponent <CharacterController2D>();
_playerInfo = player.GetComponent <PlayerInfo>();
_playerMove = player.GetComponent <PlayerMove>();
_main = GetComponent <Animator>();
_effect = transform.Find("Weapon Effect").GetComponent <Animator>();
_weaponMain = transform.Find("Weapon Main");
_spriteRenderer = _weaponMain.GetComponent <SpriteRenderer>();
_hitPoint = transform.Find("Hit Point");
_memorizer = GameObject.Find("Memorizer").GetComponent <Memorizer>();
}
private void Start()
{
_load1 = GameObject.Find("Loading_1").GetComponent <CanvasGroup>();
_load2Image = GameObject.Find("Loading_2").GetComponent <Image>();
_load2CanvasGroup = GameObject.Find("Loading_2").GetComponent <CanvasGroup>();
_load2Image.fillAmount = 0;
_memorizer = GameObject.Find("Memorizer").GetComponent <Memorizer>();
if (!_memorizer.StartScene)
{
_load1.alpha = 0;
_load2CanvasGroup.alpha = 0;
_load1.DOFade(1, 1f);
_load2CanvasGroup.DOFade(1, 1f);
}
StartCoroutine(LoadAnim());
}
public void MemorizerValidationTest()
{
int globalData = 1;
var mem = new Memorizer <int, string>(i => (i * globalData).ToString())
{
Validator = x => x + globalData
};
Assert.AreEqual("4", mem[4]);
globalData = 2;
Assert.AreEqual("8", mem[4]);
globalData = 3;
Assert.AreEqual("12", mem[4]);
globalData = 4;
Assert.AreEqual("16", mem[4]);
}
private void Awake()
{
_mainCamera = GameObject.Find("Main Camera").transform;
_memorizer = GameObject.Find("Memorizer").GetComponent <Memorizer>();
_fade = GameObject.Find("Fade").GetComponent <CanvasGroup>();
_block = GameObject.Find("Block").GetComponent <SpriteGlowEffect>();
_light = GameObject.Find("Light").GetComponent <SpriteGlowEffect>();
_leftInfo = GameObject.Find("LeftInfo").transform.GetComponent <RectTransform>();
_rightInfo = GameObject.Find("RightInfo").transform.GetComponent <RectTransform>();
_start = GameObject.Find("Start").transform.GetComponent <RectTransform>();
_last = GameObject.Find("Last").transform.GetComponent <RectTransform>();
_next = GameObject.Find("Next").transform.GetComponent <RectTransform>();
_startG = _start.GetComponent <CanvasGroup>();
_lastG = _last.GetComponent <CanvasGroup>();
_nextG = _next.GetComponent <CanvasGroup>();
_dialog = GameObject.Find("Dialog Tip Box").transform;
_dialogGroup = _dialog.GetComponent <CanvasGroup>();
_name = GameObject.Find("Name").transform.Find("NameText").transform.GetComponent <SpriteRenderer>();
//_border = GameObject.Find("Border").GetComponent<Image>();
_fade.alpha = 1;
var player = GameObject.FindGameObjectWithTag("Player");
player.GetComponent <PlayerMove>().enabled = false;
_actor = player.GetComponent <SpriteRenderer>();
_weaponMain = GameObject.FindGameObjectWithTag("Weapon").transform.Find("Weapon Main")
.GetComponent <SpriteRenderer>();
player.GetComponent <PlayerInfo>().UseWeapon = false;
var color = new Color(1, 1, 1, 0f);
_actor.color = color;
_weaponMain.color = color;
//_border.color = color;
_name.color = color;
_start.anchoredPosition = new Vector2(_start.anchoredPosition.x, _start.anchoredPosition.y - ButtonMove);
_last.anchoredPosition = new Vector2(_last.anchoredPosition.x, _last.anchoredPosition.y - ButtonMove);
_next.anchoredPosition = new Vector2(_next.anchoredPosition.x, _next.anchoredPosition.y - ButtonMove);
_startG.blocksRaycasts = false;
_lastG.blocksRaycasts = false;
_nextG.blocksRaycasts = false;
_leftInfo.anchoredPosition3D = new Vector2(_leftInfo.anchoredPosition.x - InfoMove, _leftInfo.anchoredPosition.y);
_rightInfo.anchoredPosition3D = new Vector2(_rightInfo.anchoredPosition.x + InfoMove, _rightInfo.anchoredPosition.y);
_memorizer.Selete = true;
}
internal static IEnumerable <AssemblyData> AssembliesOfferedBy(List <PackageDef> packages, IEnumerable <PackageDependency> refs, bool recursive, Memorizer <PackageDef, List <AssemblyData> > offeredFiles)
{
var files = new HashSet <AssemblyData>();
var referenced = new HashSet <PackageDependency>();
var toLookat = new Stack <PackageDependency>(refs);
while (toLookat.Any())
{
var dep = toLookat.Pop();
if (referenced.Add(dep))
{
var pkg = packages.Find(p => (p.Name == dep.Name) && dep.Version.IsCompatible(p.Version));
if (pkg != null)
{
if (recursive)
{
pkg.Dependencies.ForEach(toLookat.Push);
}
offeredFiles[pkg].ToList().ForEach(f => files.Add(f));
}
}
}
return(files);
}
public AssemblyFinder()
{
matching = new Memorizer <string, string[]>(x => allFiles.Where(y => Path.GetFileNameWithoutExtension(y) == x).ToArray());
}
internal static void findDependencies(this PackageDef pkg, List <string> excludeAdd, List <AssemblyData> searchedFiles)
{
bool foundNew = false;
var notFound = new HashSet <string>();
// First update the pre-entered dependencies
var installed = new Installation(Directory.GetCurrentDirectory()).GetPackages().Where(p => p.Name != pkg.Name).ToList();
List <string> brokenPackageNames = new List <string>();
List <AssemblyData> getPackageAssemblues(PackageDef pkgDef)
{
List <AssemblyData> output = new List <AssemblyData>();
foreach (var f in pkgDef.Files)
{
var asms = searchedFiles.Where(sf => PathUtils.AreEqual(f.FileName, sf.Location))
.Where(sf => IsDotNetAssembly(sf.Location)).ToList();
if (asms.Count == 0 && (Path.GetExtension(f.FileName).Equals(".dll", StringComparison.OrdinalIgnoreCase) || Path.GetExtension(f.FileName).Equals(".exe", StringComparison.OrdinalIgnoreCase)))
{
if (File.Exists(f.FileName))
{
// If the pluginSearcher found assemblies that are located somewhere not expected by the package definition, the package might appear broken.
// But if the file found by the pluginSearcher is the same as the one expected by the package definition we should not count it as broken.
// This could cause a package to not be added as a dependencies.
// E.g. when debugging and the OpenTAP.Cli.dll is both in the root build dir and in "Packages/OpenTAP"
var asmsIdenticalFilename = searchedFiles.Where(sf => Path.GetFileName(f.FileName) == Path.GetFileName(sf.Location));
var asmsIdentical = asmsIdenticalFilename.Where(sf => PathUtils.CompareFiles(f.FileName, sf.Location));
output.AddRange(asmsIdentical);
continue;
}
if (!brokenPackageNames.Contains(pkgDef.Name) && IsDotNetAssembly(f.FileName))
{
brokenPackageNames.Add(pkgDef.Name);
log.Warning($"Package '{pkgDef.Name}' is not installed correctly? Referenced file '{f.FileName}' was not found.");
}
}
output.AddRange(asms);
}
return(output);
};
var packageAssemblies = new Memorizer <PackageDef, List <AssemblyData> >(getPackageAssemblues);
// check versions of any hardcoded dependencies against what is currently installed
foreach (PackageDependency dep in pkg.Dependencies)
{
var installedPackage = installed.FirstOrDefault(ip => ip.Name == dep.Name);
if (installedPackage != null)
{
if (dep.Version == null)
{
dep.Version = new VersionSpecifier(installedPackage.Version, VersionMatchBehavior.Compatible);
log.Info("A version was not specified for package dependency {0}. Using installed version ({1}).", dep.Name, dep.Version);
}
else
{
if (!dep.Version.IsCompatible(installedPackage.Version))
{
throw new ExitCodeException((int)PackageCreateAction.ExitCodes.PackageDependencyError, $"Installed version of {dep.Name} ({installedPackage.Version}) is incompatible with dependency specified in package definition ({dep.Version}).");
}
}
}
else
{
throw new ExitCodeException((int)PackageCreateAction.ExitCodes.PackageDependencyError,
$"Package dependency '{dep.Name}' specified in package definition is not installed. Please install a compatible version first.");
}
}
// Find additional dependencies
do
{
foundNew = false;
// Find everything we already know about
var offeredByDependencies = AssembliesOfferedBy(installed, pkg.Dependencies, false, packageAssemblies).ToList();
var offeredByThis = packageAssemblies[pkg]
.Where(f => f != null)
.ToList();
var anyOffered = offeredByDependencies.Concat(offeredByThis).ToList();
// Find our dependencies and subtract the above two lists
var dependentAssemblyNames = pkg.Files
.SelectMany(fs => fs.DependentAssemblies)
.Where(r => r.Name != "mscorlib") // Special case. We should not bundle the framework assemblies.
.Where(r => !anyOffered.Any(of => AssemblyRefUtils.IsCompatibleReference(of, r)))
.Distinct().Where(x => !excludeAdd.Contains(x.Name)).ToList();
// If there's anything left we start resolving
if (dependentAssemblyNames.Any())
{
// First look in installed packages
var packageCandidates = new Dictionary <PackageDef, int>();
foreach (var f in installed)
{
var candidateAsms = packageAssemblies[f].Where(asm => dependentAssemblyNames.Any(dep => (dep.Name == asm.Name))).ToList();
// Don't consider a package that only matches assemblies in the Dependencies subfolder
candidateAsms.RemoveAll(asm => asm.Location.Contains("Dependencies")); // TODO: less lazy check for Dependencies subfolder would be good.
if (candidateAsms.Count > 0)
{
packageCandidates[f] = candidateAsms.Count;
}
}
// Look at the most promising candidate (i.e. the one containing most assemblies with the same names as things we need)
PackageDef candidatePkg = packageCandidates.OrderByDescending(k => k.Value).FirstOrDefault().Key;
if (candidatePkg != null)
{
foreach (AssemblyData candidateAsm in packageAssemblies[candidatePkg])
{
var requiredAsm = dependentAssemblyNames.FirstOrDefault(dep => dep.Name == candidateAsm.Name);
if (requiredAsm != null)
{
if (OpenTap.Utils.Compatible(candidateAsm.Version, requiredAsm.Version))
{
log.Info($"Satisfying assembly reference to {requiredAsm.Name} by adding dependency on package {candidatePkg.Name}");
if (candidateAsm.Version != requiredAsm.Version)
{
log.Warning($"Version of {requiredAsm.Name} in {candidatePkg.Name} is different from the version referenced in this package ({requiredAsm.Version} vs {candidateAsm.Version}).");
log.Warning($"Consider changing your version of {requiredAsm.Name} to {candidateAsm.Version} to match that in {candidatePkg.Name}.");
}
foundNew = true;
}
else
{
var depender = pkg.Files.FirstOrDefault(f => f.DependentAssemblies.Contains(requiredAsm));
if (depender == null)
{
log.Error($"This package require assembly {requiredAsm.Name} in version {requiredAsm.Version} while that assembly is already installed through package '{candidatePkg.Name}' in version {candidateAsm.Version}.");
}
else
{
log.Error($"{Path.GetFileName(depender.FileName)} in this package require assembly {requiredAsm.Name} in version {requiredAsm.Version} while that assembly is already installed through package '{candidatePkg.Name}' in version {candidateAsm.Version}.");
}
//log.Error($"Please align the version of {requiredAsm.Name} to ensure interoperability with package '{candidate.Key.Name}' or uninstall that package.");
throw new ExitCodeException((int)PackageCreateAction.ExitCodes.AssemblyDependencyError,
$"Please align the version of {requiredAsm.Name} ({candidateAsm.Version} vs {requiredAsm.Version}) to ensure interoperability with package '{candidatePkg.Name}' or uninstall that package.");
}
}
}
if (foundNew)
{
log.Info("Adding dependency on package '{0}' version {1}", candidatePkg.Name, candidatePkg.Version);
PackageDependency pd = new PackageDependency(candidatePkg.Name, new VersionSpecifier(candidatePkg.Version, VersionMatchBehavior.Compatible));
pkg.Dependencies.Add(pd);
}
}
else
{
// No installed package can offer any of the remaining referenced assemblies.
// add them as payload in this package in the Dependencies subfolder
foreach (var unknown in dependentAssemblyNames)
{
var foundAsms = searchedFiles.Where(asm => (asm.Name == unknown.Name) && OpenTap.Utils.Compatible(asm.Version, unknown.Version)).ToList();
var foundAsm = foundAsms.FirstOrDefault();
if (foundAsm != null)
{
AddFileDependencies(pkg, unknown, foundAsm);
packageAssemblies.Invalidate(pkg);
foundNew = true;
}
else if (!notFound.Contains(unknown.Name))
{
log.Debug("'{0}' could not be found in any of {1} searched assemblies, or is already added.", unknown.Name, searchedFiles.Count);
notFound.Add(unknown.Name);
}
}
}
}
}while (foundNew);
}
