private readonly SequenceDiceMainGameClass _mainGame; //if we don't need, delete.
public SequenceDiceMainViewModel(CommandContainer commandContainer,
SequenceDiceMainGameClass mainGame,
SequenceDiceVMData model,
BasicData basicData,
TestOptions test,
IGamePackageResolver resolver,
IStandardRollProcesses roller
)
: base(commandContainer, mainGame, model, basicData, test, resolver, roller)
{
_mainGame = mainGame;
}
public EightOffSolitaireMainViewModel(IEventAggregator aggregator,
CommandContainer command,
IGamePackageResolver resolver
)
: base(aggregator, command, resolver)
{
GlobalClass.MainModel = this;
ReservePiles1 = new ReservePiles(command);
ReservePiles1.Maximum = 8;
ReservePiles1.AutoSelect = HandObservable <SolitaireCard> .EnumAutoType.SelectOneOnly;
ReservePiles1.Text = "Reserve Pile";
}
public void TestCommandDispatchEmptyLine()
{
var inputReaderMock = new Mock <IInputReader>();
// Create a fake command. We want to test if it is executed.
//
var commandMock = new Mock <ICommand>();
// Let accept return false always.
//
commandMock.Setup(x => x.Accept(
It.IsAny <string>(),
It.IsAny <List <string> >()))
.Returns(false);
var commandContainer = new CommandContainer(inputReaderMock.Object);
commandContainer.AddCommand(commandMock.Object);
// Define our MOCK functionality of the StartInputLoop method. If this method is called
// our MOCK will act as a user providing a single input.
//
inputReaderMock
.Setup(x => x.StartInputLoop()).Raises((x) =>
// Notice this += is a trick the Mock library uses to fire events.
x.InputEntered += null, this, new InputReadEventArgs(""));
// Start the fake input loop, this will simulate a user input of "unknown command".
// We expect the commandMock to not accept the input. The MOCK library will remember what happened.
//
inputReaderMock.Object.StartInputLoop();
// We now check if our methods were called with the correct input. We tested what would happen if
// the user entered "unknown command".
// We expect that Accept() was called on the command mock once, and Execute() never.
//
// Set up the Execute() method of the mock, we expect it to be never called in this test.
//
commandMock.Verify(x =>
x.Execute(It.IsAny <List <string> >()), // The It class can be used to check the parameters supplied to the method.
Times.Never); // We expect the execute to not be called for the wrong command.
// Set up the mock for the Accept() method and add some constraints we expect on the parameter.
// This lets us test with what parameters and how often a method was called.
//
commandMock.Verify(x => x.Accept(
// Tests the first parameter is not null
It.IsNotNull <string>(),
// Test the second parameter is an empty list
It.Is <List <string> >((input) => input != null && input.Count == 0)),
Times.Once // We expect this method to be called exactly once.
);
}
public void CommandContainer_BindGeneric()
{
// Arrange
var container = new DiContainer();
// Act
var commandContainer = new CommandContainer(container);
var actual = commandContainer.Bind <CommandTest>();
//Assert
Assert.IsNotNull(actual);
}
public ChooseGenderViewModel(CommandContainer commandContainer, LifeBoardGameVMData model, IGenderProcesses processes, LifeBoardGameGameContainer gameContainer)
{
CommandContainer = commandContainer;
_model = model;
_processes = processes;
_gameContainer = gameContainer;
_gameContainer.SelectGenderAsync = _processes.ChoseGenderAsync;
_processes.SetInstructions = (x => Instructions = x);
_processes.SetTurn = (x => Turn = x); //has to set delegates before init obviously.
_model.GenderChooser.ItemClickedAsync += GenderChooser_ItemClickedAsync;
//_processes.Init();
}
public void CommandContainer_UnbindGeneric_ReturnFalse()
{
// Arrange
var container = new DiContainer();
// Act
var commandContainer = new CommandContainer(container);
var actual = commandContainer.Unbind <CommandTest>();
//Assert
Assert.IsFalse(actual);
}
private readonly ConnectTheDotsVMData _model; //if we don't need, delete.
public ConnectTheDotsMainViewModel(CommandContainer commandContainer,
ConnectTheDotsMainGameClass mainGame,
ConnectTheDotsVMData model,
BasicData basicData,
TestOptions test,
IGamePackageResolver resolver
)
: base(commandContainer, mainGame, model, basicData, test, resolver)
{
_mainGame = mainGame;
_model = model;
}
public MinesweeperMainViewModel(IEventAggregator aggregator,
CommandContainer commandContainer,
IGamePackageResolver resolver,
LevelClass level
)
{
_aggregator = aggregator;
LevelChosen = level.Level; //at this point, can't choose level because its already chosen.
this.PopulateMinesNeeded();
CommandContainer = commandContainer;
_mainGame = resolver.ReplaceObject <MinesweeperMainGameClass>(); //hopefully this works. means you have to really rethink.
}
public PickelCardGameMainViewModel(CommandContainer commandContainer,
PickelCardGameMainGameClass mainGame,
PickelCardGameVMData viewModel,
BasicData basicData,
TestOptions test,
IGamePackageResolver resolver
)
: base(commandContainer, mainGame, viewModel, basicData, test, resolver)
{
_model = viewModel;
_model.Deck1.NeverAutoDisable = true;
}
public GameBoardCP(CommandContainer container,
IAsyncDelayer delayer,
LottoDominosVMData model
) : base(container)
{
Columns = 7;
Rows = 4;
_delayer = delayer;
_model = model;
Text = "Dominos"; //just do here since its inherited anyways.
Visible = true; //hopefully no problem because if the view model is not shown, this won't show up anyways.
}
//will never show game over.
public FroggiesMainViewModel(IEventAggregator aggregator,
CommandContainer commandContainer,
IGamePackageResolver resolver,
LevelClass level
)
{
_aggregator = aggregator;
StartingFrogs = level.NumberOfFrogs;
NumberOfFrogs = level.NumberOfFrogs;
CommandContainer = commandContainer;
_mainGame = resolver.ReplaceObject <FroggiesMainGameClass>(); //hopefully this works. means you have to really rethink.
}
public async ValueTask Invoke(CommandArgument argument)
{
var currentArgument = argument;
if (argument.Command == null)
{
if (!CommandContainer.TryAssignCommand(argument, out var nextArgument))
{
Logger.LogWarning($"Unknown command {argument.Command}");
return;
}
else
{
currentArgument = nextArgument;
}
}
if (currentArgument.Command == "help" && CurrentScope.TryResolve <ICommandHelp>(out var help))
{
help.HandleHelp(argument);
return;
}
if (!commandHandlers.TryGetValue(currentArgument.Command, out var handlerInfo) || handlerInfo == null)
{
Logger.LogWarning($"Unknown command {argument.Command}");
return;
}
object ret;
if (handlerInfo.CommandHandler.GetParameters().Length == 0)
{
ret = handlerInfo.CommandHandler.Invoke(CommandContainer, null);
}
else
{
var parser = parsers[handlerInfo.HandlerParserType];
ret = handlerInfo.CommandHandler.Invoke(CommandContainer, parser.ParseCommandArgument(argument).ToArray());
}
if (ret != null && handlerInfo.IsAwaitable)
{
switch (ret)
{
case Task task:
await task;
return;
case ValueTask valueTask:
await valueTask;
return;
}
}
}
public Result CanCommandBeExecuted(CommandContainer args)
{
IBotCommand command = _serviceProvider.GetCommand(args.CommandName);
var descriptor = command.GetBotCommandDescriptorAttribute();
Result canExecute = command.CanExecute(args);
return(canExecute.IsSuccess
? Result.Ok()
: Result.Fail(
$"Command [{descriptor.CommandName}] cannot be executed: {canExecute}"));
}
public GolfCardGameShellViewModel(IGamePackageResolver mainContainer,
CommandContainer container,
IGameInfo gameData,
BasicData basicData,
IMultiplayerSaveState save,
TestOptions test,
GolfDelegates delegates
)
: base(mainContainer, container, gameData, basicData, save, test)
{
delegates.LoadMainScreenAsync = LoadMainScreenAsync;
}
public GameBoardVM(MancalaMainGameClass mainGame,
CommandContainer command,
BasicData basicData,
GameBoardProcesses gameBoard1
)
{
_mainGame = mainGame;
_command = command;
_basicData = basicData;
GameBoard1 = gameBoard1;
_network = _basicData.GetNetwork();
}
public MillebournesVMData(IEventAggregator aggregator, CommandContainer command)
{
Deck1 = new DeckObservablePile <MillebournesCardInformation>(aggregator, command);
Pile1 = new PileObservable <MillebournesCardInformation>(aggregator, command);
PlayerHand1 = new HandObservable <MillebournesCardInformation>(command);
OtherPile = Pile1;
Pile2 = new PileObservable <MillebournesCardInformation>(aggregator, command);
Stops = new CustomStopWatchCP();
Stops.MaxTime = 3000;
}
public HorseshoeCardGameGameContainer(BasicData basicData,
TestOptions test,
IGameInfo gameInfo,
IAsyncDelayer delay,
IEventAggregator aggregator,
CommandContainer command,
IGamePackageResolver resolver,
IListShuffler <HorseshoeCardGameCardInformation> deckList,
RandomGenerator random)
: base(basicData, test, gameInfo, delay, aggregator, command, resolver, deckList, random)
{
}
public ChineseCheckersMainViewModel(CommandContainer commandContainer,
ChineseCheckersMainGameClass mainGame,
ChineseCheckersVMData model,
BasicData basicData,
TestOptions test,
IGamePackageResolver resolver,
GameBoardProcesses gameBoard
)
: base(commandContainer, mainGame, model, basicData, test, resolver)
{
_gameBoard = gameBoard;
}
public LottoDominosMainViewModel(CommandContainer commandContainer,
LottoDominosMainGameClass mainGame,
IViewModelData viewModel,
BasicData basicData,
TestOptions test,
IGamePackageResolver resolver
)
: base(commandContainer, mainGame, viewModel, basicData, test, resolver)
{
_mainGame = mainGame;
_resolver = resolver;
}
public YahtzeeHandsDownVMData(IEventAggregator aggregator, CommandContainer command)
{
Deck1 = new DeckObservablePile <YahtzeeHandsDownCardInformation>(aggregator, command);
Pile1 = new PileObservable <YahtzeeHandsDownCardInformation>(aggregator, command);
PlayerHand1 = new HandObservable <YahtzeeHandsDownCardInformation>(command);
ComboHandList = new HandObservable <ComboCardInfo>(command);
ComboHandList.Text = "Category Cards";
ChancePile = new PileObservable <ChanceCardInfo>(aggregator, command);
ChancePile.Visible = false;
ChancePile.CurrentOnly = true;
ChancePile.Text = "Chance";
}
public ClueBoardGameVMData(CommandContainer command, IGamePackageResolver resolver, IEventAggregator aggregator)
{
_command = command;
_resolver = resolver;
HandList = new HandObservable <CardInfo>(command);
HandList.AutoSelect = HandObservable <CardInfo> .EnumAutoType.None;
HandList.Maximum = 3;
HandList.Text = "Your Cards";
Pile = new PileObservable <CardInfo>(aggregator, command);
Pile.CurrentOnly = true;
Pile.Text = "Clue";
}
public StockPileVM(CommandContainer command, IEventAggregator aggregator)
{
StockFrame = new BasicMultiplePilesCP <D>(command, aggregator);
StockFrame.Style = BasicMultiplePilesCP <D> .EnumStyleList.HasList; // for sure has a list
StockFrame.Rows = 1;
StockFrame.Columns = 1;
StockFrame.HasText = true;
StockFrame.HasFrame = true;
StockFrame.LoadBoard();
StockFrame.PileList.Single().Text = TextToAppear;
StockFrame.PileClickedAsync += StockFrame_PileClickedAsync;
}
public static void EnumSelection(this CommandContainer _container, object _value, Action <object> OnClick, bool foldOut = true)
{
Type type = _value.GetType();
if (!type.IsEnum)
{
throw new Exception("Input Must Be Enum!");
}
IEnumerable <object> enumNumerable = Enum.GetValues(type).GetEnumerable();
EnumSelection(_container, enumNumerable.FindIndex(p => p.Equals(_value)), enumNumerable.ToList(obj => obj.ToString()), value => OnClick(Enum.ToObject(type, value)), foldOut);
}
public CheckersMainViewModel(CommandContainer commandContainer,
CheckersMainGameClass mainGame,
CheckersVMData model,
BasicData basicData,
TestOptions test,
IGamePackageResolver resolver
)
: base(commandContainer, mainGame, model, basicData, test, resolver)
{
_mainGame = mainGame;
_basicData = basicData;
}
public CrazyEightsGameContainer(BasicData basicData,
TestOptions test,
IGameInfo gameInfo,
IAsyncDelayer delay,
IEventAggregator aggregator,
CommandContainer command,
IGamePackageResolver resolver,
IListShuffler <RegularSimpleCard> deckList,
RandomGenerator random)
: base(basicData, test, gameInfo, delay, aggregator, command, resolver, deckList, random)
{
}
public GolfCardGameVMData(IEventAggregator aggregator, CommandContainer command, GolfCardGameGameContainer gameContainer)
{
Deck1 = new DeckObservablePile <RegularSimpleCard>(aggregator, command);
Pile1 = new PileObservable <RegularSimpleCard>(aggregator, command);
PlayerHand1 = new HandObservable <RegularSimpleCard>(command);
OtherPile = new PileObservable <RegularSimpleCard>(aggregator, command);
OtherPile.CurrentOnly = true;
OtherPile.Text = "Current";
HiddenCards1 = new HiddenCards(gameContainer);
Beginnings1 = new Beginnings(command);
GolfHand1 = new GolfHand(gameContainer);
}
public ClockBoard(IClockVM thisMod,
ClockSolitaireMainGameClass mainGame,
CommandContainer command,
IGamePackageResolver resolver,
IEventAggregator aggregator
) : base(thisMod, command, resolver)
{
_mainGame = mainGame;
_aggregator = aggregator;
ShowCenter = true;
LoadBoard();
}
public ScatteringPiecesObservable(CommandContainer command, IGamePackageResolver resolver) : base(command)
{
//Visible = true; // the old did not have this. will always be true here.
_thisI = resolver.Resolve <IProportionImage>(TagUsed);
_rs = resolver.Resolve <RandomGenerator>();
_thisE = resolver.Resolve <EventAggregator>();
MethodInfo method = this.GetPrivateMethod(nameof(PrivateClickItemAsync));
ObjectCommand = new ControlCommand(this, method, command);
method = this.GetPrivateMethod(nameof(PrivateBoardClickAsync));
BoardCommand = new ControlCommand(this, method, command);
}
public BowlingDiceGameMainGameClass(IGamePackageResolver resolver,
IEventAggregator aggregator,
BasicData basic,
TestOptions test,
BowlingDiceGameVMData model,
IMultiplayerSaveState state,
IAsyncDelayer delay,
CommandContainer command,
BasicGameContainer <BowlingDiceGamePlayerItem, BowlingDiceGameSaveInfo> gameContainer
) : base(resolver, aggregator, basic, test, model, state, delay, command, gameContainer)
{
_test = test;
}
public ConnectFourMainGameClass(IGamePackageResolver resolver,
IEventAggregator aggregator,
BasicData basic,
TestOptions test,
ConnectFourVMData model,
IMultiplayerSaveState state,
IAsyncDelayer delay,
CommandContainer command,
ConnectFourGameContainer container
) : base(resolver, aggregator, basic, test, model, state, delay, command, container)
{
_command = command;
}
public bool Delete(CommandContainer command)
{
IEnumerable<CommandContainer> cmds = (from CommandContainer c in _commandList
where c.ClientId == command.ClientId & c.SessionId == command.SessionId & c.Id == command.Id
orderby c.Created descending
select c).Take(1);
bool commandFound = (cmds.Count() == 1);
if (commandFound) {
CommandContainer cmd = cmds.First();
_commandList.Remove(cmd);
}
return commandFound;
}
public string ProcessCommand(CommandContainer cmd)
{
TTE.Log(cmd);
//Assembly assembly = Assembly.LoadFrom(@"C:\Users\Mike\SkyDrive\TycTak\Source\TycTak.System\bin\Debug\TycTak.PlugIn.dll");
//Type type = assembly.GetType("TycTak.PlugIn.System");
//object instanceOfMyType = Activator.CreateInstance(type);
//TycTak.Engine.Core sys = new TycTak.Engine.Core();
//sys.EventProcess += new EventHandler();
//sys.SaveState(null);
//int val = sys.SaveState(resource);
//return val.ToString();
return null;
}
public void Execute(UserContainer user, CommandContainer command)
{
Log(command);
PlugInContainer plugIn = PlugInCache.Read(command.PlugInId);
if (plugIn == null | plugIn.Instance == null) {
throw new TrappedException(enmMessageCode.NoSuchPluginFound, new object[] { command.PlugInId });
} else {
Type typ = plugIn.Instance.GetType();
MethodInfo methodInfo = typ.GetMethod(command.Method);
object[] arguments = new object[command.ArgumentList.Count];
for (int i = 0; i < command.ArgumentList.Count; i++) {
arguments[i] = command.ArgumentList[i].Value;
}
object payload = methodInfo.Invoke(plugIn.Instance, arguments);
_messageProcessor.Create(command.ClientId, command.SessionId, command.SourceId, payload);
}
}
public CommandContainer Instantiate(string sourceId, string clientId, CommandContainer command)
{
Log(sourceId, clientId, command);
StatementContainer stm = StatementCache.Read(command.Id);
if (command.ArgumentList.Count != stm.ParameterList.Count) {
command.Status = enmCommandStatus.IncorrectArgument;
} else if (stm != null) {
stm.ClientId = command.ClientId;
stm.SessionId = command.SessionId;
stm.Host = command.Host;
stm.Callback = command.Callback;
stm.Created = command.Created;
stm.SourceId = command.SourceId;
stm.ArgumentList = command.ArgumentList;
stm.Status = enmCommandStatus.Initialized;
command = (CommandContainer)stm;
} else {
command.Status = enmCommandStatus.NotValid;
}
return command;
}
public CommandPrompt(IEnumerable<ICommandDescriptionProvider> providers)
{
mContainer = new CommandContainer(providers);
}
public void Create(CommandContainer command)
{
Log(command);
CommandCache.Create(command);
}
public bool Undo(CommandContainer command)
{
Log(command);
return false; // CommandController.Undo(command);
}
public void Create(CommandContainer command)
{
_commandList.Add(command);
}
// Take list of commands which have now been split and cleaned and produce command objects to execute
internal ArrayList Instantiate(string[] commands, string clientId, string sessionId, string callBack)
{
Log(commands);
ArrayList commandList = new ArrayList();
for (int i = 0; (i <= (commands.Length - 1)); i++) {
string[] parameters = Split(commands[i], true);
string[] arguments = new string[parameters.Length - 1];
List<ArgumentContainer> argumentList = new List<ArgumentContainer>();
for (int x = 1; x < parameters.Length; x++) {
argumentList.Add(new ArgumentContainer { Value = parameters[x] });
}
if (arguments.Length > 0) Array.Copy(parameters, 1, arguments, 0, arguments.Length);
string cmdName = parameters[0].ToLower();
//TODO Not tidy enough need to work on this
//TODO Need someway to thoroughly test this, maybe send 1000's of commands all different
//how about system.exec <filename>, this filename is situated on its local drive and
//has the format of test.scr. The system admin can manually put files in the bin folder.
bool noEcho = (cmdName.StartsWith("@"));
if (noEcho) cmdName = (cmdName.Substring(1, cmdName.Length - 1));
if (callBack == "") callBack = null;
string host = null;
bool isRemote = (cmdName.StartsWith("!"));
if (isRemote) {
int t = cmdName.IndexOf(" ");
if (t == -1) t = cmdName.Length;
host = cmdName.Substring(1, t - 1);
cmdName = (cmdName.Substring(t, cmdName.Length - t)).Trim();
}
// Arguments = arguments,
CommandContainer cmd = new CommandContainer { Id = cmdName, SourceId = Config.ClientId, ClientId = clientId, Host = host, SessionId = sessionId, NoEcho = noEcho, Created = DateTime.Now, Status = enmCommandStatus.Waiting, Callback = callBack, ArgumentList = argumentList };
//if (commandList == null) {
// commandList = new Command[1];
//} else {
// Array.Resize(ref commandList, commandList.Length + 1);
//}
commandList.Add(cmd);
//commandList[commandList.Length - 1] = cmd;
}
return commandList;
}
public MainForm()
{
InitializeComponent();
_saveFileDialog.Filter = _openFileDialog.Filter;
_title = Text;
NamedCommandTable commands = new NamedCommandTable();
commands.FillStandardCommands();
_commandProvider.CommandTable = commands;
CommandContainer cc = new CommandContainer();
cc.Add(new Command<TextBoxBase>(StandardCommands.Undo,
delegate(TextBoxBase control) { control.Undo(); },
delegate(TextBoxBase control) { return !control.ReadOnly && control.CanUndo; }));
cc.Add(new Command<TextBoxBase>(StandardCommands.Copy,
delegate(TextBoxBase control) { control.Copy(); },
delegate(TextBoxBase control) { return control.SelectionLength > 0; }));
cc.Add(new Command<TextBoxBase>(StandardCommands.Cut,
delegate(TextBoxBase control) { control.Cut(); },
delegate(TextBoxBase control) { return !control.ReadOnly && control.SelectionLength > 0; }));
cc.Add(new Command<TextBoxBase>(StandardCommands.Paste,
delegate(TextBoxBase control) { control.Paste(); },
delegate(TextBoxBase control) { return !control.ReadOnly && Clipboard.ContainsText(); }));
cc.Add(new Command<TextBoxBase>(StandardCommands.SelectAll,
delegate(TextBoxBase control) { control.SelectAll(); }));
_commandsByType = new Dictionary<Type, ICommandContainer>();
_commandsByType.Add(typeof(TextBoxBase), cc);
_focusWatchdog = new ControlFocusWatchdog();
_focusWatchdog.Watch(_wikiBox, _htmlBox);
switch (Settings.Default.NewLine.ToLowerInvariant())
{
case "mac":
case "cr": _newLine = "\r"; break;
case "windows":
case "win":
case "crlf": _newLine = "\r\n"; break;
case "unix":
case "lf": _newLine = "\n"; break;
default: _newLine = Environment.NewLine; break;
}
_webBrowser.DocumentCompleted += delegate { _webBrowser.AllowNavigation = false; };
}
