public BoardDiceGameClass(
IGamePackageResolver mainContainer,
IEventAggregator aggregator,
BasicData basicData,
TestOptions test,
IDiceBoardGamesData currentMod,
IMultiplayerSaveState state,
IAsyncDelayer delay,
CommandContainer command,
BasicGameContainer <P, S> gameContainer,
StandardRollProcesses <SimpleDice, P> roller
) : base(
mainContainer,
aggregator,
basicData,
test,
currentMod,
state,
delay,
command,
gameContainer)
{
_model = currentMod;
Roller = roller;
Roller.AfterRollingAsync = AfterRollingAsync;
Roller.AfterSelectUnselectDiceAsync = AfterSelectUnselectDiceAsync;
Roller.CurrentPlayer = (() => SingleInfo !);
}
public RookMainGameClass(IGamePackageResolver mainContainer,
IEventAggregator aggregator,
BasicData basicData,
TestOptions test,
RookVMData currentMod,
IMultiplayerSaveState state,
IAsyncDelayer delay,
ICardInfo <RookCardInformation> cardInfo,
CommandContainer command,
RookGameContainer gameContainer,
ITrickData trickData,
ITrickPlay trickPlay,
IAdvancedTrickProcesses aTrick,
IBidProcesses bidProcesses,
ITrumpProcesses trumpProcesses,
INestProcesses nestProcesses
)
: base(mainContainer, aggregator, basicData, test, currentMod, state, delay, cardInfo, command, gameContainer, trickData, trickPlay)
{
_model = currentMod;
_command = command;
_gameContainer = gameContainer;
_aTrick = aTrick;
_bidProcesses = bidProcesses;
_trumpProcesses = trumpProcesses;
_nestProcesses = nestProcesses;
_gameContainer.StartNewTrickAsync = StartNewTrickAsync;
_gameContainer.StartingStatus = (() => this.StartingStatus());
}
public BladesOfSteelMainGameClass(IGamePackageResolver mainContainer,
IEventAggregator aggregator,
BasicData basicData,
TestOptions test,
BladesOfSteelVMData currentMod,
IMultiplayerSaveState state,
IAsyncDelayer delay,
ICardInfo <RegularSimpleCard> cardInfo,
CommandContainer command,
BladesOfSteelGameContainer gameContainer,
IFaceoffProcesses processes,
ComputerAI ai,
BladesOfSteelScreenDelegates delegates
)
: base(mainContainer, aggregator, basicData, test, currentMod, state, delay, cardInfo, command, gameContainer)
{
_model = currentMod;
_command = command;
_gameContainer = gameContainer;
_processes = processes;
_ai = ai;
_delegates = delegates;
_gameContainer.GetAttackStage = GetAttackStage;
_gameContainer.GetDefenseStage = GetDefenseStage;
}
public SkuckCardGameMainGameClass(IGamePackageResolver mainContainer,
IEventAggregator aggregator,
BasicData basicData,
TestOptions test,
SkuckCardGameVMData currentMod,
IMultiplayerSaveState state,
IAsyncDelayer delay,
ICardInfo <SkuckCardGameCardInformation> cardInfo,
CommandContainer command,
SkuckCardGameGameContainer gameContainer,
ITrickData trickData,
ITrickPlay trickPlay,
IAdvancedTrickProcesses aTrick,
IBidProcesses bidProcesses,
IPlayChoiceProcesses choiceProcesses,
ITrumpProcesses trumpProcesses
)
: base(mainContainer, aggregator, basicData, test, currentMod, state, delay, cardInfo, command, gameContainer, trickData, trickPlay)
{
_model = currentMod;
_command = command;
_gameContainer = gameContainer;
_aTrick = aTrick;
_bidProcesses = bidProcesses;
_choiceProcesses = choiceProcesses;
_trumpProcesses = trumpProcesses;
_gameContainer.ComputerTurnAsync = ComputerTurnAsync;
_gameContainer.StartNewTrickAsync = StartNewTrickAsync;
_gameContainer.ShowHumanCanPlayAsync = ShowHumanCanPlayAsync;
}
public ThreeLetterFunMainGameClass(IGamePackageResolver resolver,
IEventAggregator aggregator,
BasicData basic,
TestOptions test,
ThreeLetterFunVMData model,
IMultiplayerSaveState state,
IAsyncDelayer delay,
CommandContainer command,
GameBoard gameboard,
GlobalHelpers global,
IListShuffler <ThreeLetterFunCardData> deck,
BasicGameContainer <ThreeLetterFunPlayerItem, ThreeLetterFunSaveInfo> gameContainer
) : base(resolver, aggregator, basic, test, model, state, delay, command, gameContainer)
{
_test = test;
_model = model;
_command = command;
_gameboard = gameboard;
_global = global;
_deck = deck;
_gameboard.SetSelf = (() =>
{
SingleInfo = PlayerList.GetSelf();
});
_gameboard.SingleInfo = (() => SingleInfo !);
_gameboard.SaveRoot = (() => SaveRoot);
}
public DiceGameClass(
IGamePackageResolver mainContainer,
IEventAggregator aggregator,
BasicData basicData,
TestOptions test,
IBasicDiceGamesData <D> currentMod,
IMultiplayerSaveState state,
IAsyncDelayer delay,
CommandContainer command,
BasicGameContainer <P, S> gameContainer,
StandardRollProcesses <D, P> roller
) : base(
mainContainer,
aggregator,
basicData,
test,
currentMod,
state,
delay,
command,
gameContainer)
{
_model = currentMod;
Roller = roller;
Roller.CurrentPlayer = (() => SingleInfo !);
Roller.AfterRollingAsync = AfterRollingAsync;
Roller.AfterSelectUnselectDiceAsync = AfterSelectUnselectDiceAsync;
//not sure about the before roll and whether it can roll (iffy).
}
public XactikaMainGameClass(IGamePackageResolver mainContainer,
IEventAggregator aggregator,
BasicData basicData,
TestOptions test,
XactikaVMData currentMod,
IMultiplayerSaveState state,
IAsyncDelayer delay,
ICardInfo <XactikaCardInformation> cardInfo,
CommandContainer command,
XactikaGameContainer gameContainer,
ITrickData trickData,
ITrickPlay trickPlay,
IAdvancedTrickProcesses aTrick,
IBidProcesses bidProcesses,
IShapeProcesses shapeProcesses,
IModeProcesses modeProcesses
)
: base(mainContainer, aggregator, basicData, test, currentMod, state, delay, cardInfo, command, gameContainer, trickData, trickPlay)
{
_model = currentMod;
_command = command;
_gameContainer = gameContainer;
_aTrick = aTrick;
_bidProcesses = bidProcesses;
_shapeProcesses = shapeProcesses;
_modeProcesses = modeProcesses;
_gameContainer.StartNewTrickAsync = StartNewTrickAsync;
_gameContainer.ShowHumanCanPlayAsync = ShowHumanCanPlayAsync;
_gameContainer.ShowTurn = (() => this.ShowTurn());
}
public BasicGameClass(IGamePackageResolver mainContainer,
IEventAggregator aggregator,
BasicData basicData,
TestOptions test,
IViewModelData currentMod,
IMultiplayerSaveState state,
IAsyncDelayer delay,
CommandContainer command,
BasicGameContainer <P, S> gameContainer
)
{
MainContainer = mainContainer;
Aggregator = aggregator;
BasicData = basicData;
Test = test;
_currentMod = currentMod;
State = state;
Delay = delay;
_command = command;
_gameContainer = gameContainer;
SaveRoot = mainContainer.Resolve <S>(); //i think this would be fine (?)
PlayerList = SaveRoot.PlayerList;
gameContainer.EndTurnAsync = EndTurnAsync;
gameContainer.ContinueTurnAsync = ContinueTurnAsync;
gameContainer.ShowWinAsync = ShowWinAsync;
gameContainer.StartNewTurnAsync = StartNewTurnAsync;
gameContainer.SaveStateAsync = SaveStateAsync;
//if i need anything else, rethink.
Network = gameContainer.Network;
Check = gameContainer.Check;
}
public MancalaMainGameClass(IGamePackageResolver resolver,
IEventAggregator aggregator,
BasicData basic,
TestOptions test,
MancalaVMData model,
IMultiplayerSaveState state,
IAsyncDelayer delay,
CommandContainer command,
GameBoardProcesses gameBoard,
BasicGameContainer <MancalaPlayerItem, MancalaSaveInfo> gameContainer
) : base(resolver, aggregator, basic, test, model, state, delay, command, gameContainer)
{
_model = model;
_command = command;
_gameBoard = gameBoard;
_gameBoard.PlayerList = GetPlayerList;
_gameBoard.SingleInfo = GetCurrentPlayer;
_gameBoard.SetCurrentPlayer = ((x) => SingleInfo = x);
_gameBoard.EndTurnAsync = EndTurnAsync;
_gameBoard.WhoTurn = GetWhoTurn;
_gameBoard.ContinueTurnAsync = ContinueTurnAsync;
_gameBoard.ShowWinAsync = ShowWinAsync;
_gameBoard.ShowTieAsync = ShowTieAsync;
_gameBoard.SaveRoot = GetSaveInfo;
GameBoardGraphicsCP.CreateSpaceList(_model);
}
public ThinkTwiceMainGameClass(IGamePackageResolver mainContainer,
IEventAggregator aggregator,
BasicData basicData,
TestOptions test,
ThinkTwiceVMData currentMod,
IMultiplayerSaveState state,
IAsyncDelayer delay,
CommandContainer command,
ThinkTwiceGameContainer gameContainer,
StandardRollProcesses <SimpleDice, ThinkTwicePlayerItem> roller,
ScoreLogic scoreLogic,
CategoriesDice categoriesDice,
Multiplier multiplier
) :
base(mainContainer, aggregator, basicData, test, currentMod, state, delay, command, gameContainer, roller)
{
_model = currentMod; //if not needed, take this out and the _model variable.
_scoreLogic = scoreLogic;
_categoriesDice = categoriesDice;
_multiplier = multiplier;
roller.BeforeRollingAsync = BeforeRollingAsync;
roller.CanRollAsync = CanRollAsync;
gameContainer.ScoreClickAsync = ScoreClickedAsync;
gameContainer.CategoryClicked = CategoryClickedAsync;
}
public RageCardGameMainGameClass(IGamePackageResolver mainContainer,
IEventAggregator aggregator,
BasicData basicData,
TestOptions test,
RageCardGameVMData currentMod,
IMultiplayerSaveState state,
IAsyncDelayer delay,
ICardInfo <RageCardGameCardInformation> cardInfo,
CommandContainer command,
RageCardGameGameContainer gameContainer,
ITrickData trickData,
ITrickPlay trickPlay,
IAdvancedTrickProcesses aTrick,
IColorProcesses colorProcesses,
IBidProcesses bidProcesses,
RageDelgates delgates
)
: base(mainContainer, aggregator, basicData, test, currentMod, state, delay, cardInfo, command, gameContainer, trickData, trickPlay)
{
_model = currentMod;
_command = command;
_gameContainer = gameContainer;
_aTrick = aTrick;
_colorProcesses = colorProcesses;
_bidProcesses = bidProcesses;
_delgates = delgates;
delgates.CardsToPassOut = (() => SaveRoot.CardsToPassOut);
}
public YahtzeeShellViewModel(IGamePackageResolver mainContainer,
CommandContainer container,
IGameInfo gameData,
BasicData basicData,
IMultiplayerSaveState save,
TestOptions test) : base(mainContainer, container, gameData, basicData, save, test)
{
}
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 UnoShellViewModel(IGamePackageResolver mainContainer,
CommandContainer container,
IGameInfo gameData,
BasicData basicData,
IMultiplayerSaveState save,
TestOptions test,
UnoColorsDelegates delegates
)
: base(mainContainer, container, gameData, basicData, save, test)
{
delegates.OpenColorAsync = OpenColorAsync;
delegates.CloseColorAsync = CloseColorAsync;
}
public TicTacToeMainGameClass(IGamePackageResolver resolver,
IEventAggregator aggregator,
BasicData basic,
TestOptions test,
TicTacToeVMData model,
IMultiplayerSaveState state,
IAsyncDelayer delay,
CommandContainer command,
BasicGameContainer <TicTacToePlayerItem, TicTacToeSaveInfo> gameContainer
) : base(resolver, aggregator, basic, test, model, state, delay, command, gameContainer)
{
_command = command;
}
public XactikaShellViewModel(IGamePackageResolver mainContainer,
CommandContainer container,
IGameInfo gameData,
BasicData basicData,
IMultiplayerSaveState save,
TestOptions test,
XactikaDelegates delegates
)
: base(mainContainer, container, gameData, basicData, save, test)
{
delegates.LoadModeAsync = LoadModeAsync;
delegates.CloseModeAsync = CloseModeAsync;
}
public PickelCardGameShellViewModel(IGamePackageResolver mainContainer,
CommandContainer container,
IGameInfo gameData,
BasicData basicData,
IMultiplayerSaveState save,
TestOptions test,
PickelDelegates delegates
)
: base(mainContainer, container, gameData, basicData, save, test)
{
delegates.CloseBiddingAsync = CloseBidAsync;
delegates.LoadBiddingAsync = LoadBidAsync;
}
public BladesOfSteelShellViewModel(IGamePackageResolver mainContainer,
CommandContainer container,
IGameInfo gameData,
BasicData basicData,
IMultiplayerSaveState save,
TestOptions test,
BladesOfSteelScreenDelegates delegates
)
: base(mainContainer, container, gameData, basicData, save, test)
{
delegates.ReloadFaceoffAsync = LoadFaceoffAsync;
delegates.LoadMainGameAsync = LoadMainGameAsync;
}
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 ItalianDominosMainGameClass(IGamePackageResolver resolver,
IEventAggregator aggregator,
BasicData basic,
TestOptions test,
ItalianDominosVMData model,
IMultiplayerSaveState state,
IAsyncDelayer delay,
CommandContainer command,
BasicGameContainer <ItalianDominosPlayerItem, ItalianDominosSaveInfo> gameContainer
) : base(resolver, aggregator, basic, test, model, state, delay, command, gameContainer)
{
_model = model;
DominosToPassOut = 6; //usually 6 but can be changed.
}
public SequenceDiceMainGameClass(IGamePackageResolver resolver,
IEventAggregator aggregator,
BasicData basic,
TestOptions test,
SequenceDiceVMData model,
IMultiplayerSaveState state,
IAsyncDelayer delay,
CommandContainer command,
SequenceDiceGameContainer container,
StandardRollProcesses <SimpleDice, SequenceDicePlayerItem> roller
) : base(resolver, aggregator, basic, test, model, state, delay, command, container, roller)
{
_model = model;
}
public A21DiceGameMainGameClass(IGamePackageResolver mainContainer,
IEventAggregator aggregator,
BasicData basicData,
TestOptions test,
A21DiceGameVMData currentMod,
IMultiplayerSaveState state,
IAsyncDelayer delay,
CommandContainer command,
BasicGameContainer <A21DiceGamePlayerItem, A21DiceGameSaveInfo> gameContainer,
StandardRollProcesses <SimpleDice, A21DiceGamePlayerItem> roller) :
base(mainContainer, aggregator, basicData, test, currentMod, state, delay, command, gameContainer, roller)
{
_model = currentMod; //if not needed, take this out and the _model variable.
_roller = roller;
}
public RageCardGameShellViewModel(IGamePackageResolver mainContainer,
CommandContainer container,
IGameInfo gameData,
BasicData basicData,
IMultiplayerSaveState save,
TestOptions test,
RageDelgates delgates
)
: base(mainContainer, container, gameData, basicData, save, test)
{
delgates.CloseBidScreenAsync = CloseBidScreenAsync;
delgates.LoadBidScreenAsync = LoadBidScreenAsync;
delgates.CloseColorScreenAsync = CloseColorScreenAsync;
delgates.LoadColorScreenAsync = LoadColorScreenAsync;
}
public BasicBoardGamesShellViewModel(
IGamePackageResolver mainContainer,
CommandContainer container,
IGameInfo gameData,
BasicData basicData,
IMultiplayerSaveState save,
TestOptions test) : base(mainContainer,
container,
gameData,
basicData,
save,
test)
{
MiscDelegates.ColorsFinishedAsync = CloseColorsAsync; //hopefully this simple this time.
}
public DominosRegularMainGameClass(IGamePackageResolver resolver,
IEventAggregator aggregator,
BasicData basic,
TestOptions test,
DominosRegularVMData model,
IMultiplayerSaveState state,
IAsyncDelayer delay,
CommandContainer command,
BasicGameContainer <DominosRegularPlayerItem, DominosRegularSaveInfo> gameContainer
) : base(resolver, aggregator, basic, test, model, state, delay, command, gameContainer)
{
_model = model;
DominosToPassOut = 6; //usually 6 but can be changed.
_model.GameBoard1.DominoPileClicked = DominoPileClicked;
}
public DominosGameClass(
IGamePackageResolver mainContainer,
IEventAggregator aggregator,
BasicData basicData,
TestOptions test,
IDominoGamesData <D> currentMod,
IMultiplayerSaveState state,
IAsyncDelayer delay,
CommandContainer command,
BasicGameContainer <P, S> gameContainer
) : base(mainContainer, aggregator, basicData, test, currentMod, state, delay, command, gameContainer)
{
_model = currentMod;
_command = command;
}
private readonly CommandContainer _command; //most of the time, needs this. if not needed, take out.
public ConcentrationMainGameClass(IGamePackageResolver mainContainer,
IEventAggregator aggregator,
BasicData basicData,
TestOptions test,
ConcentrationVMData currentMod,
IMultiplayerSaveState state,
IAsyncDelayer delay,
ICardInfo <RegularSimpleCard> cardInfo,
CommandContainer command,
ConcentrationGameContainer gameContainer)
: base(mainContainer, aggregator, basicData, test, currentMod, state, delay, cardInfo, command, gameContainer)
{
_model = currentMod;
_command = command;
}
public TileRummyMainGameClass(IGamePackageResolver resolver,
IEventAggregator aggregator,
BasicData basic,
TestOptions test,
TileRummyVMData model,
IMultiplayerSaveState state,
IAsyncDelayer delay,
CommandContainer command,
BasicGameContainer <TileRummyPlayerItem, TileRummySaveInfo> gameContainer
) : base(resolver, aggregator, basic, test, model, state, delay, command, gameContainer)
{
_model = model;
_command = command;
_rummys = new RummyProcesses <EnumColorType, EnumColorType, TileInfo>(); //decided to create new one here. hopefully i don't regret this
}
public FluxxMainGameClass(IGamePackageResolver mainContainer,
IEventAggregator aggregator,
BasicData basicData,
TestOptions test,
FluxxVMData currentMod,
IMultiplayerSaveState state,
IAsyncDelayer delay,
ICardInfo <FluxxCardInformation> cardInfo,
CommandContainer command,
FluxxGameContainer gameContainer,
IGiveTaxationProcesses giveTaxationProcesses,
IEmptyTrashProcesses emptyTrashProcesses,
IPlayProcesses playProcesses,
ActionContainer actionContainer,
KeeperContainer keeperContainer,
FluxxDelegates delegates,
IShowActionProcesses showActionProcesses,
IDiscardProcesses discardProcesses,
IRotateTradeHandProcesses rotateTradeHandProcesses,
IFinalKeeperProcesses finalKeeperProcesses,
IFinalRuleProcesses finalRuleProcesses,
IEverybodyOneProcesses everybodyOneProcesses,
IDrawUseProcesses drawUseProcesses,
IAnalyzeProcesses analyzeProcesses,
ILoadActionProcesses loadActionProcesses
)
: base(mainContainer, aggregator, basicData, test, currentMod, state, delay, cardInfo, command, gameContainer)
{
_model = currentMod;
_command = command;
_gameContainer = gameContainer;
_giveTaxationProcesses = giveTaxationProcesses;
_emptyTrashProcesses = emptyTrashProcesses;
_playProcesses = playProcesses;
_actionContainer = actionContainer;
_keeperContainer = keeperContainer;
_delegates = delegates;
_showActionProcesses = showActionProcesses;
_discardProcesses = discardProcesses;
_rotateTradeHandProcesses = rotateTradeHandProcesses;
_finalKeeperProcesses = finalKeeperProcesses;
_finalRuleProcesses = finalRuleProcesses;
_everybodyOneProcesses = everybodyOneProcesses;
_drawUseProcesses = drawUseProcesses;
_analyzeProcesses = analyzeProcesses;
_loadActionProcesses = loadActionProcesses;
_model.PlayerHand1.AutoSelect = HandObservable <FluxxCardInformation> .EnumAutoType.SelectAsMany;
}