public static void Main()
{
var manager = new DraftManager();
bool terminated = false;
while (!terminated)
{
var input = Console.ReadLine();
var cmdArgs = input.Split(' ').ToList();
var command = cmdArgs[0];
cmdArgs.RemoveAt(0);
try
{
manager.ExecuteCommand(cmdArgs, command);
}
catch (ArgumentException ae)
{
Console.WriteLine(ae.Message);
}
if (input == "Shutdown")
{
terminated = true;
}
}
}
public static void Main()
{
DraftManager draftManager = new DraftManager();
Mine mine = new Mine(draftManager);
mine.StartMining();
}
/// <summary>
/// Create a new BaconManager.
/// </summary>
/// <param name="isBackgroundTask">If this Manager should be run in the background.</param>
public BaconManager(bool isBackgroundTask)
{
// Set background task flag
IsBackgroundTask = isBackgroundTask;
// Init managers
UserMan = new UserManager(this);
ImageMan = new ImageManager(this);
SubredditMan = new SubredditManager(this);
SettingsMan = new SettingsManager(this);
NetworkMan = new NetworkManager(this);
MessageMan = new MessageManager(this);
UiSettingsMan = new UiSettingManager(this);
BackgroundMan = new BackgroundManager(this);
TileMan = new TileManager(this);
DraftMan = new DraftManager(this);
MemoryMan = new MemoryManager(this);
// Don't do this if we are a background task; it will
// call this when it is ready.
if (!isBackgroundTask)
{
FireOffUpdate();
}
// Setup the in between invoke handler for the onBackButton event. This will allow us to stop
// calling the handlers when one returns true.
m_onBackButton.SetInBetweenInvokesAction(new Func <EventArgs, bool>(InBetweenInvokeHandlerForOnBackButton));
}
internal ArenaDraftData()
{
this.Deck = new List <Triton.Game.Abstraction.EntityDef>();
DraftDisplay display = DraftDisplay.Get();
if (display.m_chosenHero != null)
{
this.Hero = new Triton.Game.Abstraction.Actor(display.m_chosenHero);
}
this.Choices = new List <Triton.Game.Abstraction.Actor>();
foreach (DraftDisplay.DraftChoice choice in display.m_choices)
{
this.Choices.Add(new Triton.Game.Abstraction.Actor(choice.m_actor));
}
DefLoader loader = DefLoader.Get();
DraftManager manager = DraftManager.Get();
foreach (CollectionDeckSlot slot in manager.m_draftDeck.m_slots)
{
for (int i = 0; i < slot.Count; i++)
{
this.Deck.Add(new Triton.Game.Abstraction.EntityDef(loader.GetEntityDef(slot.CardID)));
}
}
this.Wins = manager.m_wins;
this.Losses = manager.m_losses;
}
public ActionResult Join(string guid)
{
DraftManager draftManager = new DraftManager(_context);
DraftInviteManager draftInviteManager = new DraftInviteManager(_context);
DraftParticipantManager draftParticipantManager = new DraftParticipantManager(_context);
DraftInvite draftInvite = draftInviteManager.Get(guid);
UserManager userManager = new UserManager(_context);
User user = userManager.GetCurrentUser(User.Identity.GetUserId());
if (draftInvite == null)
{
throw new Exception();
}
else
{
Draft draft = draftManager.Get(draftInvite.DraftId);
draftInvite.Accepted = true;
draftInvite.Active = false;
draftInviteManager.Update(draftInvite);
draftParticipantManager.Add(new DraftParticipant()
{
DraftId = draftInvite.DraftId,
UserId = user.UserId,
User = user,
Name = HttpContext.User.Identity.Name,
DraftPosition = draft.DraftParticipants.Count + 1
});
}
return(RedirectToAction("Index"));
}
public static void ExecuteCommand(List <string> input, DraftManager manager)
{
string command = input[0];
List <string> arguments = input.Skip(1).ToList();
if (command.Equals("RegisterHarvester"))
{
Console.WriteLine(manager.RegisterHarvester(arguments));
}
else if (command.Equals("RegisterProvider"))
{
Console.WriteLine(manager.RegisterProvider(arguments));
}
else if (command.Equals("Day"))
{
Console.WriteLine(manager.Day());
}
else if (command.Equals("Mode"))
{
Console.WriteLine(manager.Mode(arguments));
}
else if (command.Equals("Check"))
{
Console.WriteLine(manager.Check(arguments));
}
else if (command.Equals("Shutdown"))
{
Console.WriteLine(manager.ShutDown());
}
}
private static void ProcessCommand(DraftManager dm, List <string> args, string action)
{
args = args.Skip(1).ToList();
try
{
switch (action)
{
case "RegisterHarvester":
Console.WriteLine(dm.RegisterHarvester(args));
break;
case "RegisterProvider":
Console.WriteLine(dm.RegisterProvider(args));
break;
case "Day":
Console.WriteLine(dm.Day());
break;
case "Mode":
Console.WriteLine(dm.Mode(args));
break;
case "Check":
Console.WriteLine(dm.Check(args));
break;
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public static void Main()
{
var manager = new DraftManager();
var engine = new Engine(manager);
engine.Run();
}
static void Main(string[] args)
{
string input;
var drafManager = new DraftManager();
while ((input = Console.ReadLine()) != "Shutdown")
{
var argumenst = input.Split().ToList();
var command = argumenst[0];
argumenst = argumenst.Skip(1).ToList();
switch (command)
{
case "RegisterHarvester":
Console.WriteLine(drafManager.RegisterHarvester(argumenst));
break;
case "RegisterProvider":
Console.WriteLine(drafManager.RegisterProvider(argumenst));
break;
case "Day":
Console.WriteLine(drafManager.Day());
break;
case "Mode":
Console.WriteLine(drafManager.Mode(argumenst));
break;
case "Check":
Console.WriteLine(drafManager.Check(argumenst));
break;
}
}
Console.WriteLine(drafManager.ShutDown());
}
public static void Main(string[] args)
{
DraftManager draftManager = new DraftManager();
Engine engine = new Engine(draftManager);
engine.Run();
}
public ActionResult Delete(int id)
{
DraftManager draftManager = new DraftManager(_context);
draftManager.Delete(id);
return(RedirectToAction("Index"));
}
public Engine()
{
this.inputReader = new ConsoleReader();
this.outputWriter = new ConsoleWriter();
this.inputParser = new InputParser();
this.isRunning = true;
this.draftManager = new DraftManager();
}
/// <summary>
/// Clears the draft data
/// </summary>
private void ClearDraft()
{
// Delete the data.
DraftManager.DiscardPostSubmissionDraft();
// Clear the text
ui_lastDraftSaveTime.Text = "";
}
public static DraftManager Get()
{
if (s_instance == null)
{
s_instance = new DraftManager();
}
return(s_instance);
}
public static void Main()
{
var manager = new DraftManager();
string input = Console.ReadLine();
while (true)
{
string[] tokens = input.Split().ToArray();
var args = tokens.Skip(1).ToList();
string result = string.Empty;
string command = tokens[0];
try
{
switch (command)
{
case "Shutdown":
result = manager.ShutDown();
break;
case "RegisterHarvester":
result = manager.RegisterHarvester(args);
break;
case "RegisterProvider":
result = manager.RegisterProvider(args);
break;
case "Day":
result = manager.Day();
break;
case "Mode":
result = manager.Mode(args);
break;
case "Check":
result = manager.Check(args);
break;
default:
break;
}
}
catch (ArgumentException ae)
{
result = ae.Message;
}
Console.WriteLine(result);
if (command == "Shutdown")
{
return;
}
input = Console.ReadLine();
}
}
public static void Main()
{
var harvesterFactory = new HarvesterFactory();
var providerFactory = new ProviderFactory();
var draftManager = new DraftManager(harvesterFactory, providerFactory);
var engine = new Engine(draftManager);
engine.Run();
}
public static void Main()
{
IReader reader = new Reader();
IWriter writer = new Writer();
IDraftManager draftManager = new DraftManager();
IEngine engine = new Engine(reader, writer, draftManager);
engine.Run();
}
private void DraftFlyout_Opening(object sender, object e)
{
DraftList.Clear();
var drafts = DraftManager.GetCurrent();
foreach (var item in drafts)
{
DraftList.Add(item);
}
}
public static void Main()
{
IReader reader = new ConsoleReader();
IWriter writer = new ConsoleWriter();
var manager = new DraftManager();
var engine = new Engine(reader, writer, manager);
engine.Run();
}
public void TryExecuteCommand()
{
DraftManager draftManager = new DraftManager();
string input = Console.ReadLine();
while (true)
{
List <string> inputArgs = input.Split().ToList();
string commandName = inputArgs[0];
List <string> commandArgs = inputArgs.Skip(1).ToList();
Command cmdToBeExecuted = null;
string result = string.Empty;
switch (commandName)
{
case "RegisterHarvester":
cmdToBeExecuted = new RegisterHarvesterCommand(draftManager, commandArgs);
break;
case "RegisterProvider":
cmdToBeExecuted = new RegisterProviderCommand(draftManager, commandArgs);
break;
case "Day":
cmdToBeExecuted = new StartDayCommand(draftManager, commandArgs);
break;
case "Mode":
cmdToBeExecuted = new ChangeModeCommand(draftManager, commandArgs);
break;
case "Check":
cmdToBeExecuted = new CheckStatusCommand(draftManager, commandArgs);
break;
case "Shutdown":
cmdToBeExecuted = new ShutdownCommand(draftManager, commandArgs);
Console.WriteLine(cmdToBeExecuted.Execute());
return;
}
// In case an invalid command is entered:
if (cmdToBeExecuted == null)
{
throw new ArgumentException("Invalid command.");
}
result = cmdToBeExecuted.Execute();
Console.WriteLine(result);
input = Console.ReadLine();
}
}
/// <summary>
/// Will check for an existing draft and will restore if the users wants.
/// </summary>
private async void CheckForAndPromptForDraft()
{
// If we already have info on the screen don't replace it.
if (HasInfoToDraft())
{
return;
}
// See if we have something to restore
if (await DraftManager.HasPostSubmitDraft())
{
// Make a message to show the user
var restoreDraft = true;
var message = new MessageDialog("It looks like you have draft of a submission, would you like to restore it?", "Draft Restore");
message.Commands.Add(new UICommand(
"Restore Draft",
(IUICommand command) => { restoreDraft = true; }));
message.Commands.Add(new UICommand(
"Discard Draft",
(IUICommand command) => { restoreDraft = false; }));
message.DefaultCommandIndex = 0;
message.CancelCommandIndex = 1;
// Show the dialog
await message.ShowAsync();
if (restoreDraft)
{
// Get the data
var data = await App.BaconMan.DraftMan.GetPostSubmissionDraft();
if (data != null)
{
// Restore it
ui_postTitleTextBox.Text = data.Title;
ui_postUrlTextBox.Text = data.UrlOrText;
ui_isSelfPostCheckBox.IsChecked = data.IsSelfText;
ui_subredditSuggestBox.Text = data.Subreddit;
// If we are self text open the box
if (ui_isSelfPostCheckBox.IsChecked.Value)
{
IsSelfPostCheckBox_Click(null, null);
}
}
}
else
{
// Delete the data.
ClearDraft();
}
}
}
public static void Main()
{
DraftManager draftManager = new DraftManager();
string input;
while ((input = Console.ReadLine()) != "Shutdown")
{
var args = input.Split().ToList();
var command = args[0];
args = args.Skip(1).ToList();
string rslt = null;
try
{
switch (command)
{
case "RegisterHarvester":
rslt = draftManager.RegisterHarvester(args);
break;
case "RegisterProvider":
rslt = draftManager.RegisterProvider(args);
break;
case "Day":
rslt = draftManager.Day();
break;
case "Check":
rslt = draftManager.Check(args);
break;
case "Mode":
rslt = draftManager.Mode(args);
break;
default:
throw new ArgumentException("Invalid command");
}
Console.WriteLine(rslt);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
Console.WriteLine(draftManager.ShutDown());
}
public void Run()
{
this.draftManager = new DraftManager();
var input = Console.ReadLine();
while (input != "Shutdown")
{
var inputTokens = input.Split(' ');
ExecuteCommand(inputTokens);
input = Console.ReadLine();
}
Console.WriteLine(draftManager.ShutDown());
}
public void Start()
{
string command;
var manager = new DraftManager();
bool shouldContinue = true;
var input = Console.ReadLine().Split(new[] { ' ', '\t', '\n' }, StringSplitOptions.RemoveEmptyEntries).ToList();
while (shouldContinue)
{
switch (input[0])
{
case "RegisterHarvester":
input.RemoveAt(0);
Console.WriteLine(manager.RegisterHarvester(input));;
break;
case "RegisterProvider":
input.RemoveAt(0);
Console.WriteLine(manager.RegisterProvider(input));;
break;
case "Day":
Console.WriteLine(manager.Day());
break;
case "Mode":
input.RemoveAt(0);
Console.WriteLine(manager.Mode(input));
break;
case "Check":
input.RemoveAt(0);
Console.WriteLine(manager.Check(input));
break;
case "Shutdown":
Console.WriteLine(manager.ShutDown());
shouldContinue = false;
break;
}
if (!shouldContinue)
{
break;
}
input = Console.ReadLine().Split(new[] { ' ', '\t', '\n' }, StringSplitOptions.RemoveEmptyEntries).ToList();
}
}
public static void Main(string[] args)
{
IDraftManager draftManager = new DraftManager();
IReader reader = new ConsoleReader();
IWriter writer = new ConsoleWriter();
IEnergyRepository energyRepository = new EnergyRepository();
IHarvesterController harvesterController = new HarvesterController(energyRepository);
IProviderController providerController = new ProviderController(energyRepository);
ICommandInterpreter commandInterpreter = new CommandInterpreter(harvesterController, providerController);
Engine engine = new Engine(draftManager, reader, writer, commandInterpreter);
engine.Run();
}
public static void Main()
{
var manager = new DraftManager();
while (true)
{
var inputLine = Console.ReadLine();
manager.CommandInterpreter(inputLine);
if (inputLine.Equals("Shutdown"))
{
break;
}
}
}
private IEnumerator _DraftRefresh(EffectState state)
{
DraftManager draftZone = Constants.BATTLE.Field.GetDraftZone();
yield return(Constants.BATTLE.StartCoroutine(AnimationStart(state.animation, draftZone.gameObject)));
List <Card> draftCards = draftZone.GetCards();
foreach (Card c in draftCards)
{
c.Disp();
}
draftZone.DraftCharge();
}
public static void Main()
{
DraftManager manager = new DraftManager();
while (true)
{
List <string> input = Console.ReadLine().Split().ToList();
ExecuteCommands.ExecuteCommand(input, manager);
if (input[0].Equals("Shutdown"))
{
break;
}
}
}
public void PrüftReturnStringDerRegisterMethodsImManager()
{
// Arrange
var dummyList = new List <string> {
"ENQ-16853-4588", "5000", "2600", "HAmMeR"
};
const string expectedString = "Neuen hammer-Harvester erfolgreich registriert.";
// Act
var manager = new DraftManager();
var returnString = manager.RegisterHarvester(dummyList);
// Assert
Assert.AreEqual(expectedString, returnString);
}
static void Main(string[] args)
{
DraftManager draft = new DraftManager();
while (true)
{
try
{
var input = Console.ReadLine()
.Split(new string[] { " " }, StringSplitOptions.RemoveEmptyEntries)
.ToList();
string command = input[0];
List <string> inputToPass = input.Skip(1).ToList();
if (command == "RegisterHarvester")
{
Console.WriteLine(draft.RegisterHarvester(inputToPass));
}
else if (command == "RegisterProvider")
{
Console.WriteLine(draft.RegisterProvider(inputToPass));
}
else if (command == "Day")
{
Console.WriteLine(draft.Day());
}
else if (command == "Check")
{
Console.WriteLine(draft.Check(inputToPass));
}
else if (command == "Mode")
{
Console.WriteLine(draft.Mode(inputToPass));
}
else if (command == "Shutdown")
{
Console.WriteLine(draft.ShutDown());
Environment.Exit(0);
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
}
