public ConsoleSession(byte columns, byte rows, ConsoleManager consoleManager)
{
Columns = columns;
Rows = rows;
ConsoleManager = consoleManager;
text = new byte[Columns * Rows];
textcolor = new byte[Columns * Rows];
}
public static ConsoleManager getInstance ()
{
if ( _meInstance == null )
{
_meInstance = GameObject.Find ( "_ConsoleObject" ).GetComponent < ConsoleManager > ();
}
return _meInstance;
}
public GameManager()
{
_gameSize = new Size(BlockSize * 4, BlockSize * 4);
_consoleManager = new ConsoleManager();
_consoleState = _consoleManager.SaveConsoleState();
_consoleManager.SetForGraphics();
_consoleManager.ResizeConsoleWindow(_gameSize);
}
public void ConsoleManager_Constructor_CreatesConsoleManager()
{
// Arrange
var processFactory = new MockProcessFactory();
// Act
var cm = new ConsoleManager(processFactory);
// Assert
Assert.IsInstanceOfType(cm, typeof(ConsoleManager));
}
public static ArrayList prepareCommand ( ArrayList allCommands, string name, Pointer < float > pointerValue, string valueType, ConsoleManager.CallBackFunction callBack, string commandType, string password = NO_PASSWORD )
{
ArrayList command = new ArrayList ();
command.Add ( name );
command.Add ( pointerValue );
command.Add ( valueType );
command.Add ( callBack );
command.Add ( commandType );
command.Add ( password );
allCommands.Add ( command );
return new ArrayList ();
}
public void ConsoleManager_InvokeCommand_AddsHistory()
{
// Arrange
var processFactory = new MockProcessFactory
{
MockCreateProcess_StartInfo = startInfo => new MockProcessWrapper()
};
var cm = new ConsoleManager(processFactory);
// Act
cm.InvokeCommand("hello", "world");
// Assert
Assert.AreEqual(cm.History.ElementAt(0), "hello world");
}
public SelectDevkitDialog(IServiceProvider sp)
{
this.Consoles = new ObservableCollection<ConsoleWrapper>();
InitializeComponent();
this.DataContext = this;
this.Loaded += SelectDevkitDialog_Loaded;
this.notificationService = sp.GetService(typeof(IUserNotificationService)) as IUserNotificationService;
this.consoleManager = new ConsoleManager();
this.removals = new List<ConsoleWrapper>();
InitConsolesList();
this.consoleManager.ConsoleAdded += OnConsolesChanged;
this.consoleManager.ConsoleRemoved += OnConsolesChanged;
this.consoleManager.DefaultConsoleChanged += OnConsolesChanged;
}
public void SetDungeonEventObjectInformation(int id, string uniqueName)
{
if (_currentGuid != null && uniqueName != null)
{
try
{
var dun = GetCurrentDungeon((Guid)_currentGuid);
if (dun == null || _currentGuid == null || dun.DungeonEventObjects?.Any(x => x.Id == id) == true)
{
return;
}
var eventObject = new DungeonEventObject()
{
UniqueName = uniqueName,
IsBossChest = DungeonObjectData.IsBossChest(uniqueName),
Id = id
};
dun.DungeonEventObjects?.Add(eventObject);
dun.Faction = DungeonObjectData.GetFaction(uniqueName);
if (dun.Mode == DungeonMode.Unknown)
{
dun.Mode = DungeonObjectData.GetDungeonMode(uniqueName);
}
}
catch (Exception e)
{
ConsoleManager.WriteLineForError(MethodBase.GetCurrentMethod().DeclaringType, e);
Log.Error(MethodBase.GetCurrentMethod().DeclaringType, e);
}
}
SetDungeonStatsDay();
SetDungeonStatsTotal();
}
public void OnBeginPlay()
{
Assert.IsFalse(variable.IsBool);
Assert.IsFalse(variable.IsFloat);
Assert.IsFalse(variable.IsString);
Assert.IsTrue(variable.IsInt);
Assert.IsTrue(variable.GetInt() == variableValue);
variable.SetOnChangedCallback(VariableEvent);
ConsoleManager.RegisterCommand(consoleCommand, "Executes a test command", ConsoleCommand);
Assert.IsTrue(ConsoleManager.IsRegisteredVariable(consoleCommand));
Engine.AddActionMapping(pauseResumeAction, pauseResumeKey);
Engine.AddAxisMapping(mouseXAction, mouseXKey);
Engine.AddAxisMapping(mouseYAction, mouseYKey);
playerInput.AddActionMapping(playerCommandAction, playerCommandKey);
InputComponent inputComponent = playerController.InputComponent;
Assert.IsFalse(inputComponent.HasBindings);
inputComponent.BindAction(pauseResumeAction, InputEvent.Pressed, PauseResume, true);
inputComponent.BindAction(playerCommandAction, InputEvent.Pressed, PlayerCommand, true);
inputComponent.BindAxis(mouseXAction, MouseXMessage);
inputComponent.BindAxis(mouseYAction, MouseYMessage);
Assert.IsTrue(inputComponent.HasBindings);
Assert.IsTrue(inputComponent.ActionBindingsNumber == 2);
const string removableAction = "TestRemovable";
const string removableKey = Keys.R;
playerInput.AddActionMapping(removableAction, removableKey, ctrl: true, alt: true);
playerInput.RemoveActionMapping(removableAction, removableKey);
}
public void Shutdown(bool terminate = true)
{
lock (_bootInProgressLocker)
{
if (ConsoleManager == null)
{
return;
}
ConsoleManager.Warning("Core", "Shutting down IHI!");
if (CoreManager.ServerCore.OfficalEventFirer == null)
{
return;
}
IHIEventArgs eventArgs = new IHIEventArgs();
CoreManager.ServerCore.OfficalEventFirer.Fire("shutdown:before", eventArgs);
CoreManager.ServerCore.OfficalEventFirer.Fire("shutdown:after", eventArgs);
if (WebAdminManager == null)
{
return;
}
WebAdminManager.Stop();
Config = null;
System.Console.Beep(4000, 100);
System.Console.Beep(3500, 100);
System.Console.Beep(3000, 100);
System.Console.Beep(2500, 100);
System.Console.Beep(2000, 100);
System.Console.Beep(1500, 100);
System.Console.Beep(1000, 100);
}
}
private Point ParseSeat(string x)
{
var binary = x.Select(x => ParseChar(x));
var binStr = binary.Select(x => x ? '1' : '0').ToList();
binStr.Insert(7, '-');
var row = FromBinary(binary.SkipLast(3));
var col = FromBinary(binary.Skip(7));
var seat = new Point(row, col);
if (col >= 4)
{
System.Console.ForegroundColor = ConsoleColor.Green;
}
else
{
System.Console.ForegroundColor = ConsoleColor.Blue;
}
Console.WriteLine($"Seat {x} → {new string(binStr.ToArray())} → row {row.ToString("000")}, col {col.ToString("00")} → ID {GetSeatId(seat)}");
return(seat);
}
//-----------------------------------------------------------------
public override long Part1(string input)
{
for (int i = 0; i < 10; i++)
{
Thread.Sleep(100);
_itteration?.SetValue(i);
var f = (float)RandomGen.NextDouble();
_aFloat?.SetValue(f);
_aFormatedFloat?.SetValue(f);
Console.WriteLine("Itteration " + i);
var percent = i * 1f / 9f;
_percent1?.SetValue(percent);
_percent2?.SetValue(percent);
_percent3?.SetValue(percent);
_percent4?.SetValue(percent);
_percent5?.SetValue(percent);
_percent6?.SetValue(percent);
}
return((long)(RandomGen.NextDouble() * 1000));
}
/// <summary>
/// Returns true if an existing discovery is succesfully selected and upgraded
/// </summary>
/// <returns></returns>
ResearchResult _tryUpgradeDiscovery()
{
var nonMaxxed = DiscoveryLevels.Where(a => (a.Value < ResearchHandler.MaxResearchLevel));
if (nonMaxxed.Count() != 0)
{
var resToUpgrade = nonMaxxed.ElementAt(Rand.Random.Next(0, nonMaxxed.Count()));
DiscoveryLevels[resToUpgrade.Key] += 1;
#if DEBUG
ConsoleManager.WriteLine("Discovered " + resToUpgrade.Key.ToString() + " level " + DiscoveryLevels[resToUpgrade.Key], ConsoleMessageType.Debug);
#endif
return(new ResearchResult()
{
Discovery = resToUpgrade.Key, Level = resToUpgrade.Value
});
}
else
{
return(null);
}
}
/// <summary>
/// Runs AI game.
/// </summary>
/// <param name="command">The AI command.</param>
private void RunGame(Command command)
{
var colorArgument = command.GetArgument <string>(0);
var preferredTimeArgument = command.GetArgument <float>(1);
var helperTasksCount = command.GetArgument <int>(2);
var colorParseResult = Enum.TryParse(colorArgument, true, out Color color);
if (!colorParseResult)
{
ConsoleManager.WriteLine($"$rInvalid color type ($R{color}$r)");
return;
}
_playerColor = color;
_preferredTime = preferredTimeArgument;
_helperTasksCount = helperTasksCount;
if (_playerColor == Color.Black)
{
MoveAI();
}
}
/// <summary>Reads the working package file.</summary>
/// <returns>The <see cref="string" />.</returns>
public static string Read()
{
if (PackageManager.WorkingPackage == null)
{
ConsoleManager.WriteOutput(Descriptions.CommandDescriptions[12]);
ConsoleManager.WriteOutput("Usage: Read");
Console.WriteLine();
}
else
{
try
{
StringManager.DrawPackageTable(PackageManager.WorkingPackage);
Console.WriteLine();
}
catch (Exception e)
{
ExceptionsManager.WriteException(e.Message);
}
}
return(string.Empty);
}
private (int indexStart, int indexEnd)? FindContiguousSum(List <long> numbers, long target)
{
for (int left = 0; left < numbers.Count - 1; left++)
{
var sum = numbers[left];
var right = left;
_progress?.SetValue(left / (float)numbers.Count);
_currentIndex?.SetValue(left);
do
{
right++;
sum += numbers[right];
if (sum == target)
{
return(left, right);
}
} while (sum < target && right < numbers.Count);
Console.WriteLine($"{left.ToString("000")} to {right.ToString("000")} = {sum}");
}
return(null);
}
//-----------------------------------------------------------------
public override long Part1(string input)
{
LinkedList <int> cups = PlayGameWithLinkedList(input, 100, 10, true);
Console.WriteLine($"-- Final --\ncups: {cups.GetPrintStr()}");
var score = "";
var scoreCup = cups.Find(1);
while (cups.Count != 0)
{
var lastCup = scoreCup;
scoreCup = scoreCup.NextOrFirst();
cups.Remove(lastCup);
if (scoreCup != null)
{
score += scoreCup.Value.ToString();
}
}
score = score.Remove(score.Length - 1);
return(long.Parse(score));
}
public static void PrintLogInfo(ManualLogSource log)
{
var consoleTitle = $"BepInEx {Paths.BepInExVersion} - {Paths.ProcessName}";
log.Log(LogLevel.Message, consoleTitle);
if (ConsoleManager.ConsoleActive)
{
ConsoleManager.SetConsoleTitle(consoleTitle);
}
//See BuildInfoAttribute for more information about this section.
var attributes = typeof(BuildInfoAttribute).Assembly.GetCustomAttributes(typeof(BuildInfoAttribute), false);
if (attributes.Length > 0)
{
var attribute = (BuildInfoAttribute)attributes[0];
log.Log(LogLevel.Message, attribute.Info);
}
Logger.Log(LogLevel.Info, $"System platform: {GetPlatformString()}");
Logger.Log(LogLevel.Info, $"Process bitness: {(PlatformUtils.ProcessIs64Bit ? "64-bit (x64)" : "32-bit (x86)")}");
}
static void Run()
{
while (true)
{
//TODO: move to time with autoreset disabled
if (TimeKeeper.MsSinceInitialization - _lastUpdateTimeStamp >=
_simulatorConfig.MainManagerUpdateIntervalMS)
{
_lastUpdateTimeStamp = TimeKeeper.MsSinceInitialization;
_mainManager.Update(null, null);
if (TimeKeeper.MsSinceInitialization - _lastUpdateTimeStamp >
_simulatorConfig.MainManagerUpdateIntervalMS)
{
ConsoleManager.WriteLine("WARNING: TIMED UPDATES LATE IN SIMULATOR",
ConsoleMessageType.Warning);
}
}
Thread.Sleep(1);
}
}
internal static void Load()
{
try
{
Paths.SetExecutablePath(typeof(HN.Program).Assembly.GetName().Name);
Logger.Listeners.Add(new ConsoleLogger());
AccessTools.PropertySetter(typeof(TraceLogSource), nameof(TraceLogSource.IsListening)).Invoke(null, new object[] { true });
ConsoleManager.Initialize(true);
// Start chainloader for plugins
var chainloader = new HacknetChainloader();
chainloader.Initialize();
chainloader.Execute();
}
catch (Exception ex)
{
Console.WriteLine("Fatal loading exception:");
Console.WriteLine(ex);
Console.ReadLine();
Environment.Exit(1);
}
}
public InventoryPutItemEvent(Dictionary <byte, object> parameters) : base(parameters)
{
ConsoleManager.WriteLineForNetworkHandler(GetType().Name, parameters);
try
{
if (parameters.ContainsKey(0))
{
ObjectId = parameters[0].ObjectToLong();
}
if (parameters.ContainsKey(2))
{
InteractGuid = parameters[2].ObjectToGuid();
}
}
catch (Exception e)
{
ObjectId = null;
InteractGuid = null;
ConsoleManager.WriteLineForError(MethodBase.GetCurrentMethod().DeclaringType, e);
}
}
public async Task <string> RunInterfaceAsync(List <HistoryItem> history)
{
var historyToDisplay = history.Select(x => x.CmdLine).Distinct().ToList();
var control = Build(historyToDisplay);
ConsoleManager.Setup();
ConsoleManager.Content = control;
ConsoleManager.Resize(new ConsoleGUI.Space.Size(Console.WindowWidth, Console.WindowHeight));
ConsoleManager.AdjustWindowSize();
var inputListener = new IInputListener[]
{
this,
listView,
searchBox
};
quit = false;
while (!quit)
{
ConsoleManager.AdjustBufferSize();
ConsoleManager.ReadInput(inputListener);
if (updateSearch)
{
updateSearch = false;
var searchResults = historyToDisplay.Where(x => x.ToLowerInvariant().Contains(searchBox.Text.ToLowerInvariant())).ToList();
listView.Items = searchResults;
}
await Task.Delay(50);
}
return(listView.SelectedItem);
}
public void ManageEnemyTurn()
{
if (enemy.healthBar.value * 100 > 50)
{
float totalDamage = enemy.CalculateDamage() * player.defense;
StartCoroutine(ChangeSliderValue(player.healthBar, totalDamage, "Player"));
enemy.GetComponent <AudioSource> ().Play();
ConsoleManager.AddText(player.id + " was wounded for " + totalDamage + "\n");
if (player.healthBar.value <= 0)
{
panelDefeat.SetActive(true);
}
}
if (enemy.healthBar.value * 100 < 25)
{
//Cover("Enemy");
}
else
{
int chance = Random.Range(0, 1);
if (chance == 1)
{
float totalDamage = 10 - player.defense;
StartCoroutine(ChangeSliderValue(player.healthBar, totalDamage, "Player"));
if (player.healthBar.value <= 0)
{
panelDefeat.SetActive(true);
}
}
else
{
//Cover("Enemy");
}
}
}
public MasterServerManager(MasterServerConfig c, GalacticProperties gp, IDatabaseManager dbm, IDbIdIoService dbIdIoService, RedisServer redisServer, SlaveServerConfigService slaveServerConfigService)
{
_redisServer = redisServer;
_databaseManager = dbm;
_dbIdIoService = dbIdIoService;
_slaveServerConfigService = slaveServerConfigService;
MasterServerConfig = c;
GalacticProperties = gp;
SlaveID = _slaveServerConfigService.CurrentServiceId;
if (!_checkForMasterServer())
{
List <PSystemModel> allSystems = new List <PSystemModel>(_databaseManager.GetAllSystemsAsync().Result);
_promoteToMasterServer(MasterServerConfig, GalacticProperties, allSystems, _databaseManager, _dbIdIoService, _redisServer);
}
else
{
#if DEBUG
ConsoleManager.WriteLine("Existing master server detected. Initializating as slave only.", ConsoleMessageType.Debug);
#endif
}
if (!IsMasterServer)
{
ConsoleManager.WriteLine("Initializing as slave only.", ConsoleMessageType.Notification);//Leaving this here to remember to log it later, might be useful
}
_connectToServer();
redisServer.Subscribe(MessageTypes.Redis_SlaveConnectionResponse, _handleSlaveConnectionResponse);
_pingTimer = new Timer(c.SlaveHeartbeatPeriodMS);
_pingTimer.Elapsed += _updateSlaveHeartbeat;
_pingTimer.Start();
}
public void RunInCmd(EventHandler <MessageHandler.MessageEventArgs> logger = null)
{
try
{
if (IsWin10)
{
ConsoleManager.EnableVtMode();
}
ServiceMode = false;
MessageHandler.Message += logger ?? CommandlineLogger;
OnStart(Environment.GetCommandLineArgs());
Console.Title = $@"{ServiceName} - Press Escape to Exit";
while (!(Console.KeyAvailable && Console.ReadKey(true).Key.Equals(ConsoleKey.Escape)))
{
Thread.Sleep(10);
}
OnStop();
MessageHandler.Message -= logger ?? CommandlineLogger;
if (IsWin10)
{
ConsoleManager.DisableVtMode();
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
Console.ReadKey();
}
}
/// <summary>
/// Initializes a new instance of the <see cref = "Crawl" /> class.
/// </summary>
/// <param name = "crawler">The crawler.</param>
/// <param name="actionManager"></param>
/// <param name="crawlRequestManager"></param>
/// <param name="discoveryManager"></param>
/// <param name="htmlManager"></param>
/// <param name="politenessManager"></param>
/// <param name="ruleManager"></param>
/// <param name = "processData">if set to <c>true</c> [process data].</param>
public Crawl(ApplicationSettings applicationSettings, WebSettings webSettings, Crawler <TArachnodeDAO> crawler, ActionManager <TArachnodeDAO> actionManager, ConsoleManager <TArachnodeDAO> consoleManager, CookieManager cookieManager, CrawlRequestManager <TArachnodeDAO> crawlRequestManager, DataTypeManager <TArachnodeDAO> dataTypeManager, DiscoveryManager <TArachnodeDAO> discoveryManager, EncodingManager <TArachnodeDAO> encodingManager, HtmlManager <TArachnodeDAO> htmlManager, PolitenessManager <TArachnodeDAO> politenessManager, ProxyManager <TArachnodeDAO> proxyManager, RuleManager <TArachnodeDAO> ruleManager, bool processData)
{
_applicationSettings = applicationSettings;
_webSettings = webSettings;
UncrawledCrawlRequests = new PriorityQueue <CrawlRequest <TArachnodeDAO> >();
UnassignedDiscoveries = new HashSet <string>();
_crawler = crawler;
_crawlInfo.MaximumCrawlDepth = 1;
_actionManager = actionManager;
_consoleManager = consoleManager;
_cookieManager = cookieManager;
_crawlRequestManager = crawlRequestManager;
_dataTypeManager = dataTypeManager;
_discoveryManager = discoveryManager;
_encodingManager = encodingManager;
_htmlManager = htmlManager;
_politenessManager = politenessManager;
_proxyManager = proxyManager;
_ruleManager = ruleManager;
_processData = processData;
_arachnodeDAO = (TArachnodeDAO)Activator.CreateInstance(typeof(TArachnodeDAO), _applicationSettings.ConnectionString, _applicationSettings, _webSettings, false, false);
_arachnodeDAO.ApplicationSettings = applicationSettings;
//_arachnodeDAO.OpenCommandConnections();
_dataManager = new DataManager <TArachnodeDAO>(_applicationSettings, _webSettings, _actionManager, _dataTypeManager, _discoveryManager, _ruleManager, _arachnodeDAO);
_fileManager = new FileManager <TArachnodeDAO>(_applicationSettings, _webSettings, _discoveryManager, _arachnodeDAO);
_imageManager = new ImageManager <TArachnodeDAO>(_applicationSettings, _webSettings, _discoveryManager, _arachnodeDAO);
_webClient = new WebClient <TArachnodeDAO>(_applicationSettings, _webSettings, _consoleManager, _cookieManager, _proxyManager);
_webPageManager = new WebPageManager <TArachnodeDAO>(_applicationSettings, _webSettings, _discoveryManager, _htmlManager, _arachnodeDAO);
}
public static void Main(string[] args)
{
var logPath = "application.log";
var logger = new AggregatedLogger(
new FileLogger(logPath),
new ConsoleLogger()
);
IConsoleManager consoleManager = new ConsoleManager();
var environment = new AppEnvironment(consoleManager);
try
{
var envelopes = environment.Parse(args);
var analysis = environment.CheckEnvelopes(envelopes);
do
{
consoleManager.WriteLine($"{analysis}");
envelopes = environment.RequestExtraEnvelopes();
if (envelopes == null)
{
break;
}
analysis = environment.CheckEnvelopes(envelopes);
}while (envelopes.Any());
}
catch (Exception ex)
{
logger.LogInformation(ex.Message);
}
}
//-----------------------------------------------------------------
public override long Part2(string input)
{
var program = CodeCompiler.ParseProgram(input);
for (var instructionLine = 7; instructionLine < program.Instructions.Count; instructionLine++)
{
var instruction = program.Instructions[instructionLine];
if (instruction.Operation == "jmp")
{
program.Instructions[instructionLine] = new CodeInstruction("nop", instruction.Argument);
}
else if (instruction.Operation == "nop")
{
program.Instructions[instructionLine] = new CodeInstruction("jmp", instruction.Argument);
}
else
{
continue;
}
Console.WriteLine($"Trying with change of line {instructionLine}\n");
int infinitProtection = 10000;
while (infinitProtection-- > 0)
{
if (program.IsProgramDone)
{
return(program.CurrentState.Accumulator);
}
program.Step();
//Console.WriteLine(program.GetStateString());
}
program = CodeCompiler.ParseProgram(input);
}
return(0);
}
public int[,] Transformed()
{
//int[] tab = size_tab();
int[] tab = { 40, 40 };
int[,] tableau = new int[40, 40];
ConsoleManager.Show();
for (int i = 0; i < tableau.GetLength(0); i++)
{
for (int j = 0; j < tableau.GetLength(1); j++)
{
tableau[i, j] = 1;
}
}
for (int i = 0; i < 5; i++)
{
for (int j = 0; j < 5; j++)
{
tableau[i, j] = -1;
}
}
foreach (IMappedImageInfo e in map)
{
for (int y = 0; y < e.ImageInfo.Height; y++)
{
for (int x = 0; x < e.ImageInfo.Width; x++)
{
tableau[y + e.Y, x + e.X] = -1;
////probleme d'inexation commen tretrouver l'indexe en fonction de la largeur de colomne et le reste
}
}
}
return(tableau);
}
public async Task <SingleResponse <int> > EmployeesActions(EmployeeDto employee)
{
using (_httpClient = new HttpClient())
{
var endPoint = "Employees/API/";
_httpClient.BaseAddress = new Uri(_baseAddress);
_httpClient.DefaultRequestHeaders.Clear();
_httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/x-www-form-urlencoded"));
if (employee.EmployeeId == 0)
{
endPoint += "AddEmployee";
}
else
{
endPoint += "EditEmployee";
}
var payload = EncodeContent(employee);
var response = await _httpClient.PostAsync(endPoint, payload);
if (response.IsSuccessStatusCode)
{
var responseContent = await response.Content.ReadAsStringAsync();
var result = JsonConvert.DeserializeObject <SingleResponse <int> >(responseContent);
if (result.Success == 1)
{
return(result);
}
ConsoleManager.Show();
Console.WriteLine(result.Message);
Console.ReadKey();
}
return(null);
}
}
/// <summary>
/// Uses network discovery to find servers
/// </summary>
void DiscoverServers()
{
// Discover on default port
Colorful.Console.WriteLine("Discovering Servers...");
client.DiscoverLocalPeers(Program.DefaultPort);
// Check for answers after x seconds
Thread.Sleep(2000);
Console.WriteLine($"Found {gameServers.Count} server(s)");
// Ask user if to continue to discover on custom port
do
{
// Get input
string s = ConsoleManager.WaitGetPriorityInput("Input server port to continue discovering or leave empty to stop");
if (s.Length > 0)
{
// Parse input
if (int.TryParse(s, out int p))
{
Colorful.Console.WriteLine("Discovering Servers...");
client.DiscoverLocalPeers(p);
Thread.Sleep(1200);
Console.WriteLine($"Found {gameServers.Count} server(s)");
}
else
{
Console.WriteLine("input is not a valid port");
}
}
else
{
break; // If input is empty stop discovery
}
}while (true);
}
public PartySilverGainedEvent(Dictionary <byte, object> parameters) : base(parameters)
{
ConsoleManager.WriteLineForNetworkHandler(GetType().Name, parameters);
try
{
foreach (var parameter in parameters)
{
Debug.Print($"{parameter}");
}
if (parameters.ContainsKey(0))
{
TimeStamp = new GameTimeStamp(parameters[0].ObjectToLong() ?? 0);
}
if (parameters.ContainsKey(1))
{
TargetEntityId = parameters[1].ObjectToLong();
}
if (parameters.ContainsKey(2))
{
SilverNet = FixPoint.FromInternalValue(parameters[2].ObjectToLong() ?? 0);
}
if (parameters.ContainsKey(3))
{
SilverPreTax = FixPoint.FromInternalValue(parameters[3].ObjectToLong() ?? 0);
}
}
catch (Exception e)
{
ConsoleManager.WriteLineForError(MethodBase.GetCurrentMethod().DeclaringType, e);
}
}
protected override void OnEventWritten(EventWrittenEventArgs e)
{
var color = ConsoleColor.Gray;
switch (e.Level)
{
case EventLevel.Informational:
color = ConsoleColor.White;
break;
case EventLevel.Warning:
color = ConsoleColor.Yellow;
break;
case EventLevel.Error:
case EventLevel.Critical:
color = ConsoleColor.Red;
break;
}
ConsoleManager.PushColor(color);
Console.WriteLine(e.Payload[0]);
ConsoleManager.PopColor();
}
public static void ChangeTheStatus()
{
Console.WriteLine("Enter ID of user:"******"Enter ID of order:");
int idOfOrder = ConsoleManager.ReadInt();
if (FindOrderByID(idOfOrder, AccountManager.FindUserById(choiceOfUser)) != null)
{
FindOrderByID(idOfOrder, AccountManager.FindUserById(choiceOfUser)).Status = ChoosenStatus();
}
else
{
Console.WriteLine("There is no such order!");
Console.WriteLine("Please, type the enter to continue...)");
}
}
else
{
Console.WriteLine("There is no such user, \nplease, create it first!");
}
}
public override void OnEventWritten(EventLevels level, string message)
{
ConsoleColor color = ConsoleColor.Gray;
switch (level)
{
case EventLevels.Info:
color = ConsoleColor.White;
break;
case EventLevels.Warning:
color = ConsoleColor.Yellow;
break;
case EventLevels.Error:
case EventLevels.Critical:
color = ConsoleColor.Red;
break;
}
ConsoleManager.PushColor(color);
Console.WriteLine(message);
ConsoleManager.PopColor();
}
/// <summary>
/// Draws all fields attacked by pieces with the specified color.
/// </summary>
/// <param name="command">The Attacks command.</param>
private void DrawAttacks(Command command)
{
var colorArgument = command.GetArgument <string>(0);
List <Position> attacks;
if (colorArgument == "all")
{
attacks = VisualBoard.FriendlyBoard.GetAttacks();
}
else
{
var colorTypeParseResult = Enum.TryParse(colorArgument, true, out Color colorType);
if (!colorTypeParseResult)
{
ConsoleManager.WriteLine($"$rInvalid color parameter ($R{colorArgument}$r)");
return;
}
attacks = VisualBoard.FriendlyBoard.GetAttacks(colorType);
}
VisualBoard.AddExternalSelections(attacks);
}
public void ConsoleManager_InvokeCommand_CallsProcessStart()
{
var _processStartCalled = false;
// Arrange
var processFactory = new MockProcessFactory
{
MockCreateProcess_StartInfo = startInfo =>
{
return new MockProcessWrapper
{
MockStart = () => _processStartCalled = true
};
}
};
var cm = new ConsoleManager(processFactory);
// Act
cm.InvokeCommand("hello", "world");
// Assert
Assert.IsTrue(_processStartCalled);
}
public void Execute(HashSet <Field> fields)
{
int[][] grid = this.generator.GenerateNewSukoku();
this.solver.SolveSudoku(grid);
int[][] solvedGrid = this.solver.GetGrid;
ConsoleManager.SetCursorPosition(BoardConstants.InformationCol, BoardConstants.InformationRow);
ConsoleManager.SetColor(BoardConstants.DefaultPromptColor);
if (this.isCorrect(grid, fields))
{
ConsoleManager.WriteLine(ButtonsConstants.SolutionIsCorrectMsg);
}
else
{
ConsoleManager.WriteLine(ButtonsConstants.SolutionIsInCorrectMsg);
}
ConsoleManager.SetCursorPosition(0, 0);
Console.ReadKey();
Console.Clear();
Environment.Exit(0);
}
/// <summary>
/// Initializes a new instance of the <see cref="ConsoleSession"/> class.
/// </summary>
public ConsoleSession(ConsoleManager consoleManager)
: this(80, 40, consoleManager)
{
}
public static ConsoleIdentifier GetDefaultConsole()
{
using (var manager = new ConsoleManager())
{
var defaultConsole = manager.GetDefaultConsole();
if (defaultConsole == null)
{
return null;
}
return new ConsoleIdentifier(defaultConsole.Alias, defaultConsole.Address, true);
}
}
protected override void OnClosed(EventArgs e)
{
this.consoleManager.ConsoleAdded -= OnConsolesChanged;
this.consoleManager.ConsoleRemoved -= OnConsolesChanged;
this.consoleManager.DefaultConsoleChanged -= OnConsolesChanged;
this.consoleManager.Dispose();
this.consoleManager = null;
base.OnClosed(e);
}
public static ConsoleIdentifier CreateConsole(string nameOrAddress)
{
using (var manager = new ConsoleManager())
{
var consoles = manager.GetConsoles();
var defaultConsole = manager.GetDefaultConsole();
XtfConsole console;
if (string.IsNullOrEmpty(nameOrAddress))
{
// Null means use the default console
console = defaultConsole;
if (console == null)
{
return null;
}
}
else
{
// Try to find a console with an alias matching that given
console = consoles.FirstOrDefault(c => StringComparer.OrdinalIgnoreCase.Equals(c.Alias, nameOrAddress));
if (console == null)
{
// Not found by alias, try by address.
console = consoles.FirstOrDefault(c => StringComparer.OrdinalIgnoreCase.Equals(c.Address, nameOrAddress));
if (console == null)
{
// Couldn't find one, so we'll assume the value given is an address
return new ConsoleIdentifier(nameOrAddress, nameOrAddress, false);
}
}
}
return new ConsoleIdentifier(console.Alias, console.Address, StringComparer.OrdinalIgnoreCase.Equals(console.Alias, defaultConsole.Alias));
}
}
public static void Setup()
{
Controller = new ConsoleManager();
}
// Use this for initialization
void Start()
{
DontDestroyOnLoad(gameObject);
if (CommandLineManager.IsServer)
{
gameServer = gameObject.AddComponent<ServerImplmentation>();
cmdLineManager = gameObject.AddComponent<ConsoleManager>();
}
else
{
manager = gameObject.AddComponent<SteamManager>();
gameClient = new GClient();
gameClient.DataRecieved += GameClient_DataRecieved;
gameClient.ConnectionStatusChanged += GameClient_ConnectionStatusChanged;
gameClient.ConnectingToServer += GameClient_ConnectingToServer;
gameClient.MatchmakingListFoundServer += GameClient_MatchmakingListFoundServer;
//request = gameClient.RefreshList(EServerList.LAN);
}
}
/// <summary>
/// The entry point of the program.
/// </summary>
private static void Main()
{
GridManager gridManager = new GridManager();
IIOManager ioManager = new ConsoleManager();
GameEngine.Run(gridManager, ioManager);
}
static void Main()
{
ConsoleManager consoleManager = new ConsoleManager(new Keyboard(), 150);
consoleManager.Start();
}
public void CallConsoleManager()
{
var cm = new ConsoleManager();
cm.ShowDialog();
}
