public async Task CheckEnvironmentWorks()
{
using (var console = new ConsoleRedirector())
{
var code = await MainEntry.Main(new[] { "CheckEnvironment" });
Assert.AreEqual(0, code);
this.AssertContainsCopyright(console.Lines);
this.AssertContainsGitHashAndVersion(console.Lines);
StringAssert.Contains(console.Lines[4], "SUCCESS - Valid environment");
}
}
public async Task DefaultHelpWorks()
{
using (var console = new ConsoleRedirector())
{
var code = await MainEntry.Main(new[] { "--help" });
Assert.AreEqual(0, code);
this.AssertContainsCopyright(console.Lines);
this.AssertContainsGitHashAndVersion(console.Lines);
StringAssert.StartsWith(console.Lines[6], Meta.Description);
}
}
public override void fight(int damageDone, Entity enemy)
{
Console.ForegroundColor = ConsoleColor.DarkRed;
Console.WriteLine("{0} did {1} damage to {2}", name, attack, enemy.getName());
MainEntry.space();
enemy.health -= attack;
Console.ResetColor();
MainEntry.space();
getInfo();
}
public async Task DefaultVersionWorks()
{
using (var console = new ConsoleRedirector())
{
var code = await MainEntry.Main(new[] { "--version" });
Assert.AreEqual(0, code);
this.AssertContainsCopyright(console.Lines);
this.AssertContainsGitHashAndVersion(console.Lines);
StringAssert.StartsWith(console.Lines[3], BuildMetadata.VersionString);
}
}
public override void Initialize()
{
mainEntry = GameObject.FindObjectOfType <MainEntry>();
Timer.Instance.Initialize();
InputManager.Instance.Initialize();
UIManager.Instance.Initialize();
PlayerManager.Instance.Initialize(this);
RoomManager.Instance.Initialize();
EnemyManager.Instance.Initialize();
ProjectileManager.Instance.Initialize();
initialized = true;
isGame = true;
}
//[DataRow(LinuxMuslX64)]
//[DataRow(LinuxArm)]
//[DataRow(LinuxArm64)]
//[DataRow(WinArm64)]
public async Task CheckEnvironmentWorks(string rid)
{
using var console = new ConsoleRedirector();
var code = await MainEntry.Main(new[] { "CheckEnvironment" });
Trace.WriteLine(console.Lines.Join(Environment.NewLine));
Assert.AreEqual(0, code);
this.AssertContainsCopyright(console.Lines);
this.AssertContainsGitHashAndVersion(console.Lines);
if (IsMacOsX)
{
StringAssert.Contains(console.Lines[4], SoxAudioUtility.Mp3NotSupportedOnOSX);
}
StringAssert.Contains(console.Lines[^ 2], "SUCCESS - Valid environment");
public override Task <int> Execute(CommandLineApplication app)
{
if (this.CommandName.IsNullOrEmpty())
{
MainEntry.PrintUsage(null, MainEntry.Usages.Single, HelpCommandName);
}
else if (this.CommandName == Meta.Name)
{
MainEntry.PrintUsage(null, MainEntry.Usages.All);
}
else
{
MainEntry.PrintUsage(null, MainEntry.Usages.Single, this.CommandName);
}
return(this.Ok());
}
Task <JsonResult> TaskSetup(string ip, ushort rate, ushort gain)
{
return(Task.Run(() =>
{
bool received = false;
string receiveip = "";
MainEntry.SendC(ip, rate, gain, (obj) =>
{
receiveip = (string)obj;
if (receiveip == "error")
{
}
else
{
received = true;
ConnectedTerminalState t = _ConnectedTerminals.GetStringKey(receiveip);
if (t != null)
{
t.mRate = rate;
t.mGain = gain;
}
}
});
int timeout = 5000;
while (!received)
{
Thread.Sleep(1000);
timeout -= 1000;
if (received)
{
return Json(
new { ips = _ConnectedTerminals });
}
if (timeout < 0)
{
break;
}
}
return Json(new { ips = _ConnectedTerminals });
}));
}
public void Initialize()
{
//render = UI.GetComponent<Renderer>();
//------------Initializes the win screen------------//
//winScreen = GameObject.FindObjectOfType<WinScreen>();
//winScreen.Initialize(this);
//-------------------------------------------------//
CreateUI();
mainEntry = GameObject.FindObjectOfType <MainEntry>();
uiLinks = GameObject.FindObjectOfType <UILinks>();
//fix this Image prefab not loading properly
uiLinks.currentWeapon.sprite = uiLinks.weapon1;
AddListenerToButtons();
}
Task <JsonResult> TaskStartStop(string ip, bool start)
{
return(Task.Run(() =>
{
bool received = false;
string receiveip = "";
MainEntry.SendS(ip, start, (obj) =>
{
receiveip = (string)obj; if (receiveip == "error")
{
}
else
{
received = true;
ConnectedTerminalState t = _ConnectedTerminals.GetStringKey(receiveip);
if (t != null)
{
t.mIsStart = start;
}
}
});
int timeout = 5000;
while (!received)
{
Thread.Sleep(1000);
timeout -= 1000;
if (received)
{
return Json(
new { ips = _ConnectedTerminals });
}
if (timeout < 0)
{
break;
}
}
return Json(new { ips = _ConnectedTerminals });
}));
}
public void Draw(Graphics g, SwitchBase sw, DrawableBase parent, RenderingEngine e)
{
MainEntry.Draw(g, sw, parent, e);
for (int i = 0; i < sw.InputsSet.Count; i++)
{
if (Inputs.ContainsKey(i))
{
Inputs[i].DrawInput(g, sw, i, e);
}
}
for (int i = 0; i < sw.OutputsSet.Count; i++)
{
if (Outputs.ContainsKey(i))
{
Outputs[i].DrawOutput(g, sw, i, e);
}
}
}
public void PromptNonInteractive()
{
MainEntry.SetLogVerbosity(LogVerbosity.Info, false);
using (var stringWriter = new StringWriter())
{
Console.SetOut(stringWriter);
LoggedConsole.WriteLine("Test");
LoggedConsole.SuppressInteractive = true;
var result = LoggedConsole.Prompt("Enter your name:");
var actual = stringWriter.ToString();
StringAssert.Contains(actual, "User prompt \"Enter your name:\" suppressed because session is not interactive");
Assert.AreEqual(null, result);
}
MainEntry.SetLogVerbosity(LogVerbosity.Warn, true);
}
public async Task <IActionResult> StartupDetails(int id)
{
UserStartup specificStartup = _context.UserStartup.Find(id);
if (specificStartup.Identifier != null)
{
Dictionary <string, MainEntry> seamlessDictionary = await _seamlessDAL.GetMainDictionary();
MainEntry me = seamlessDictionary[specificStartup.Identifier];
specificStartup.Alignment = me.Alignment;
specificStartup.City = me.City;
specificStartup.CompanyWebsite = me.CompanyWebsite;
specificStartup.Country = me.Country;
specificStartup.Landscape = me.Landscape;
specificStartup.Raised = me.Raised;
if (DateTime.TryParse(me.ReviewDate, out DateTime r))
{
specificStartup.ReviewDate = r;
}
specificStartup.Scout = me.Scout;
specificStartup.Source = me.Source;
specificStartup.StateProvince = me.StateProvince;
if (int.TryParse(me.Team, out int t))
{
specificStartup.Team = t;
}
specificStartup.Technology = me.TechnologyAreas;
specificStartup.Theme = me.Themes;
if (int.TryParse(me.Uniqueness, out int u))
{
specificStartup.Uniqueness = u;
}
specificStartup.TwoLineSummary = me.TwoLineCompanySummary;
}
UserStartupComments userStartupComments = new UserStartupComments()
{
Startups = specificStartup,
Comments = _context.StartupComments.Where(x => x.StartupId == id).ToList(),
};
return(View(userStartupComments));
}
Task <JsonResult> TaskSetupAll(List <TerminalDto> ts, ushort rate, ushort gain)
{
ConnectedTerminalState cts;
return(Task.Run(() =>
{
_ConnectedTerminals.Clear();
foreach (TerminalDto t in ts)
{
string receiveip = "";
MainEntry.SendC(t.ip, rate, gain, (obj) =>
{
receiveip = (string)obj;
if (receiveip == "error")
{
}
else
{
if (!_ConnectedTerminals.ContainsStringKey(receiveip))
{
_ConnectedTerminals.AddIfNotExistStringKey(receiveip);
cts = _ConnectedTerminals.GetStringKey(receiveip);
if (cts != null)
{
cts.mRate = rate;
cts.mGain = gain;
}
}
}
});
}
int timeout = 5000;
Thread.Sleep(timeout);
return Json(new { ips = _ConnectedTerminals, state = "ok" });
}));
}
private void Awake()
{
if (instance == null)
{
instance = this;
DontDestroyOnLoad(gameObject);
this.thisIsAFreshGame = false;
this.level = 1;
}
else
{
Destroy(gameObject);
}
this.mainTrack = transform.GetComponent <AudioSource>();
this.inTutorialMode = false;
this.inGameMode = false;
this.gameFinished = false;
this.gameWon = false;
}
public async Task <IActionResult> AddSeamlessStartupEntry(string key)
{
if (key == null)
{
return(RedirectToAction("DisplaySavedSeamlessStartupEntries"));
}
Dictionary <string, MainEntry> seamlessDictionary = await _seamlessDAL.GetMainDictionary();
MainEntry startupDetails = seamlessDictionary[key];
UserStartup us = new UserStartup()
{
Identifier = key,
UserId = User.FindFirstValue(ClaimTypes.NameIdentifier),
DateAdded = DateTime.Parse(startupDetails.DateAdded),
CompanyName = startupDetails.CompanyName
};
List <UserStartup> userStartups = await _context.UserStartup.Where(x => x.UserId == User.FindFirstValue(ClaimTypes.NameIdentifier)).ToListAsync();
bool found = false;
foreach (UserStartup y in userStartups)
{
if (y.CompanyName == us.CompanyName)
{
found = true;
}
}
if (!found)
{
_context.UserStartup.Add(us);
_context.SaveChanges();
return(RedirectToAction("UserFavorites"));
}
else
{
TempData["Status"] = "This Favorite has already been added!";
return(RedirectToAction("UserFavorites"));
}
}
public void BasicCli()
{
var tempA = this.outputDirectory.CreateSubdirectory("A");
var tempB = this.outputDirectory.CreateSubdirectory("B");
var args = new[]
{
"DrawRibbonPlots",
tempA.FullName,
tempB.FullName,
"-o",
this.outputDirectory.FullName,
"-z",
"-12:34",
"-m",
"05:06",
};
var app = MainEntry.CreateCommandLineApplication();
var parseResult = app.Parse(args);
Assert.IsNotNull(parseResult.SelectedCommand);
Assert.IsInstanceOfType(parseResult.SelectedCommand, typeof(CommandLineApplication <global::AnalysisPrograms.Draw.RibbonPlots.RibbonPlot.Arguments>));
var arguments = ((CommandLineApplication <global::AnalysisPrograms.Draw.RibbonPlots.RibbonPlot.Arguments>)parseResult.SelectedCommand).Model;
CollectionAssert.That.AreEquivalent(
new[]
{
tempA,
tempB,
},
arguments.InputDirectories);
Assert.That.AreEqual(this.outputDirectory, arguments.OutputDirectory);
Assert.AreEqual(new TimeSpan(-12, -34, 00), arguments.TimeSpanOffsetHint);
Assert.AreEqual(new TimeSpan(5, 6, 00), arguments.Midnight);
}
Task <JsonResult> TaskSync(string ip)
{
return(Task.Run(() =>
{
bool received = false;
string receiveip = "";
MainEntry.SendY(ip, (obj) => {
receiveip = (string)obj;
received = true;
if (!_ConnectedGroundTruths.ContainsStringKey(receiveip))
{
_ConnectedGroundTruths.AddIfNotExistStringKey(receiveip);
}
});
int timeout = 5000;
while (!received)
{
Thread.Sleep(1000);
timeout -= 1000;
if (received)
{
return Json(
new { ips = _ConnectedGroundTruths });
}
if (timeout < 0)
{
break;
}
}
if (_ConnectedGroundTruths.ContainsStringKey(receiveip))
{
_ConnectedGroundTruths.RemoveIfExistStringKey(receiveip);
}
return Json(new { ips = _ConnectedGroundTruths });
}));
}
public void debugScreen()
{
Console.Clear();
int preLeft = Console.CursorLeft;
int preTop = Console.CursorTop;
Console.CursorLeft = 60;
Console.CursorTop = 5;
Console.Write("Health = " + getHealth());
MainEntry.space();
Console.CursorLeft = 60;
Console.Write("Attack = " + getAttack());
MainEntry.space();
Console.CursorLeft = 60;
Console.Write("Wallet = {0}", getMoney());
MainEntry.space();
Console.CursorLeft = 60;
Console.Write("XP = " + getXP());
MainEntry.space();
Console.CursorLeft = preLeft;
Console.CursorTop = preTop;
Console.WriteLine("Money = {0}", money);
}
private void ShowHideListbox(bool show)
{
if (show)
{
SuggestedItemsRepeaterView.ItemsSource = _availableSuggestions;
if (!SuggestedItemsContainerBottom.IsVisible)
{
OnSuggestionOpen?.Invoke(this, new EventArgs());
SuggestedItemsRepeaterView.IsVisible = true;
}
SuggestedItemsOuterContainer.IsVisible = show;
SuggestedItemsContainerBottom.IsVisible = show;
}
else
{
if (SuggestedItemsContainerBottom.IsVisible)
{
MainEntry.Unfocus();
Unfocus();
OnSuggestionClose?.Invoke(this, new EventArgs());
}
if (SuggestedItemsRepeaterView.IsVisible)
{
SuggestedItemsRepeaterView.IsVisible = false;
}
if (SuggestedItemsOuterContainer.IsVisible)
{
SuggestedItemsOuterContainer.IsVisible = false;
}
SuggestedItemsContainerBottom.IsVisible = false;
}
}
void Awake()
{
if (!Application.isEditor)
{
}
if (Application.isPlaying)
{
MainEntry a = null;
#if USE_BUNDLE
a = new MainEntryR2();
#else
switch (entryType)
{
case MainEntryTp.LUA:
a = new MainEntryR1();
break;
case MainEntryTp.KUI:
a = new MainEntryR2();
break;
default:
a = new MainEntryR1();
break;
}
#endif
if (a != null)
{
a.Setup(this.gameObject);
}
}
}
public async Task <IActionResult> SeamlessStartupDetails(string key)
{
if (key == null)
{
return(RedirectToAction("DisplaySeamlessStartup"));
}
Dictionary <string, MainEntry> seamlessDictionary = await _seamlessDAL.GetMainDictionary();
KeyValuePair <string, MainEntry> startupDetails = new KeyValuePair <string, MainEntry>(key, seamlessDictionary[key]);
List <UserStartup> definedUserStartUps = new List <UserStartup>();
string uId = User.FindFirstValue(ClaimTypes.NameIdentifier);
definedUserStartUps = _context.UserStartup.Where(x => x.UserId == uId).Where(x => x.Identifier == null).ToList();
List <UserStartup> userSavedSeamlessStartups = _context.UserStartup.Where(x => x.UserId == uId).Where(x => x.Identifier != null).ToList();
List <UserStartup> finalDisplayList = new List <UserStartup>();
foreach (UserStartup us in userSavedSeamlessStartups)
{
//GET THE REST OF THE DETAILS
MainEntry me = seamlessDictionary[us.Identifier];
us.Alignment = me.Alignment;
us.City = me.City;
us.CompanyWebsite = me.CompanyWebsite;
us.Country = me.Country;
us.Landscape = me.Landscape;
us.Raised = me.Raised;
if (DateTime.TryParse(me.ReviewDate, out DateTime r))
{
us.ReviewDate = r;
}
us.Scout = me.Scout;
us.Source = me.Source;
us.StateProvince = me.StateProvince;
if (int.TryParse(me.Team, out int t))
{
us.Team = t;
}
us.Technology = me.TechnologyAreas;
us.Theme = me.Themes;
if (int.TryParse(me.Uniqueness, out int u))
{
us.Uniqueness = u;
}
us.TwoLineSummary = me.TwoLineCompanySummary;
finalDisplayList.Add(us);
}
foreach (UserStartup us in definedUserStartUps)
{
finalDisplayList.Add(us);
}
foreach (UserStartup us in finalDisplayList)
{
if (startupDetails.Value.CompanyName == us.CompanyName)
{
int id = us.Id;
return(RedirectToAction("StartupDetails", new { id = id }));
}
}
return(View(startupDetails));
}
} // End of CheckIFCanBuy
public virtual void ContextMenu(String[] menuItems, int SizeOfRow)
{
menuList = new string[menuItems.Length];
for (int i = 0; i < menuItems.Length; i++)
{
menuList[i] = menuItems[i];
}
this.SizeOfRow = SizeOfRow;
/*
############
# Move #####
* Attack ###
* Items ####
* */
Console.Clear();
MainEntry.space();
Console.WriteLine("What would you like to do?");
for (int i = 0; i < SizeOfRow; i++)
{
Console.Write(outLine);
}
Console.WriteLine();
//Console.WriteLine("#############");
for (int i = 0; i < menuList.Length; i++)
{
Console.Write(outLine + space + space);
//Implement own EventHandler
if (i == 0 && selected == 0)
{
Console.Write(cursor);
}
if (i == 1 && selected == 1)
{
Console.Write(cursor);
}
if (i == 2 && selected == 2)
{
Console.Write(cursor);
}
Console.Write(menuList[i]);
size = menuList[i].Length;
Console.Write(space);
for (int padd = size; padd < (SizeOfRow - 4); padd++)
{
Console.Write(outLine);
}
Console.WriteLine();
//Console.WriteLine("#############");
size = 0;
}
for (int j = 0; j < SizeOfRow; j++)
{
Console.Write(outLine);
}
keykontroll();
}
//trigger from app.xaml.cs
public void WPFFormShow()
{
mainForm = new MainEntry(this);
mainForm.Show();
}
public override Task <int> Execute(CommandLineApplication app)
{
MainEntry.PrintUsage(null, MainEntry.Usages.ListAvailable);
return(this.Ok());
}
public void HelpPagingIsDisabled()
{
var app = MainEntry.CreateCommandLineApplication();
Assert.IsFalse(app.UsePagerForHelpText);
}
public void CloseEntry()
{
EntryPage.SetActive(true);
MainEntry.SetActive(false);
}
/// <summary>
/// This entrypoint should be used for testing short files (less than 2 minutes)
/// </summary>
public static void Execute(Arguments arguments)
{
MainEntry.WarnIfDevleoperEntryUsed("EventRecognizer entry does not do any audio maniuplation.");
Log.Info("Running event recognizer");
var sourceAudio = arguments.Source;
var configFile = arguments.Config.ToFileInfo();
var outputDirectory = arguments.Output;
if (configFile == null)
{
throw new FileNotFoundException("No config file argument provided");
}
else if (!configFile.Exists)
{
Log.Warn($"Config file {configFile.FullName} not found... attempting to resolve config file");
configFile = ConfigFile.Resolve(configFile.Name, Directory.GetCurrentDirectory().ToDirectoryInfo());
}
LoggedConsole.WriteLine("# Recording file: " + sourceAudio.FullName);
LoggedConsole.WriteLine("# Configuration file: " + configFile);
LoggedConsole.WriteLine("# Output folder: " + outputDirectory);
// find an appropriate event IAnalyzer
IAnalyser2 recognizer = AnalyseLongRecording.FindAndCheckAnalyser <IEventRecognizer>(
arguments.AnalysisIdentifier,
configFile.Name);
Log.Info("Attempting to run recognizer: " + recognizer.Identifier);
Log.Info("Reading configuration file");
Config configuration = ConfigFile.Deserialize <RecognizerBase.RecognizerConfig>(configFile);
// get default settings
AnalysisSettings analysisSettings = recognizer.DefaultSettings;
// convert arguments to analysis settings
analysisSettings = arguments.ToAnalysisSettings(
analysisSettings,
outputIntermediate: true,
resultSubDirectory: recognizer.Identifier,
configuration: configuration);
// Enable this if you want the Config file ResampleRate parameter to work.
// Generally however the ResampleRate should remain at 22050Hz for all recognizers.
//analysisSettings.AnalysisTargetSampleRate = (int) configuration[AnalysisKeys.ResampleRate];
// get transform input audio file - if needed
Log.Info("Querying source audio file");
var audioUtilityRequest = new AudioUtilityRequest()
{
TargetSampleRate = analysisSettings.AnalysisTargetSampleRate,
};
var preparedFile = AudioFilePreparer.PrepareFile(
outputDirectory,
sourceAudio,
MediaTypes.MediaTypeWav,
audioUtilityRequest,
outputDirectory);
var source = preparedFile.SourceInfo.ToSegment();
var prepared = preparedFile.TargetInfo.ToSegment(FileSegment.FileDateBehavior.None);
var segmentSettings = new SegmentSettings <FileInfo>(
analysisSettings,
source,
(analysisSettings.AnalysisOutputDirectory, analysisSettings.AnalysisTempDirectory),
prepared);
if (preparedFile.TargetInfo.SampleRate.Value != analysisSettings.AnalysisTargetSampleRate)
{
Log.Warn("Input audio sample rate does not match target sample rate");
}
// Execute a pre analyzer hook
recognizer.BeforeAnalyze(analysisSettings);
// execute actual analysis - output data will be written
Log.Info("Running recognizer: " + recognizer.Identifier);
AnalysisResult2 results = recognizer.Analyze(analysisSettings, segmentSettings);
// run summarize code - output data can be written
Log.Info("Running recognizer summary: " + recognizer.Identifier);
recognizer.SummariseResults(
analysisSettings,
source,
results.Events,
results.SummaryIndices,
results.SpectralIndices,
new[] { results });
//Log.Info("Recognizer run, saving extra results");
// TODO: Michael, output anything else as you wish.
Log.Debug("Clean up temporary files");
if (source.Source.FullName != prepared.Source.FullName)
{
prepared.Source.Delete();
}
int eventCount = results?.Events?.Length ?? 0;
Log.Info($"Number of detected events: {eventCount}");
Log.Success(recognizer.Identifier + " recognizer has completed");
}
public void TestHangBeforeExitDoesNotThrowException()
{
Assertions.DoesNotThrow <NullReferenceException>(() => MainEntry.HangBeforeExit());
}
private void ContextMenu()
{
/*
############
# Move ####
* Attack ###
* Items ###
* */
//Console.Clear();
MainEntry.space();
player.debugScreen();
Console.WriteLine("What would you like to do?");
Console.WriteLine("#############");
for (int i = 0; i < menuList.Length; i++)
{
Console.Write(outLine + space + space);
//Cursor Logic
if (selected == 0 && i == 0)
{
Console.Write(cursor);
}
if (i == 1)
{
if (selected == 1)
{
Console.Write(cursor);
}
}
if (i == 2)
{
if (selected == 2)
{
Console.Write(cursor);
}
}
if (i == 3)
{
if (selected == 3)
{
Console.Write(cursor);
}
}
if (i == 4)
{
if (selected == 4)
{
Console.Write(cursor);
}
}
if (i == 5)
{
if (selected == 5)
{
Console.Write(cursor);
}
}
Console.Write(menuList[i]);
size = menuList[i].Length;
Console.Write(space);
for (int padd = size; padd < 9; padd++)
{
Console.Write(outLine);
}
Console.WriteLine();
Console.WriteLine("#############");
size = 0;
}
keykontroll();
}
