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 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 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 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 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 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 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 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 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 BeginningColorProcessorClass(BeginningColorModel <E, O, P> model,
BasicGameContainer <P, S> gameContainer
)
{
_model = model;
_gameContainer = gameContainer;
//looks like i have to set a delegate for showing for all now with pauses.
MiscDelegates.ComputerChooseColorsAsync = ComputerChooseColorAsync;
MiscDelegates.ContinueColorsAsync = ContinueColorsAsync;
MiscDelegates.FillRestColors = (() =>
{
_model.ColorChooser.FillInRestOfColors();
});
}
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;
}
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 DominosMexicanTrainMainGameClass(IGamePackageResolver resolver,
IEventAggregator aggregator,
BasicData basic,
TestOptions test,
DominosMexicanTrainVMData model,
IMultiplayerSaveState state,
IAsyncDelayer delay,
CommandContainer command,
GlobalClass global,
BasicGameContainer <DominosMexicanTrainPlayerItem, DominosMexicanTrainSaveInfo> gameContainer
) : base(resolver, aggregator, basic, test, model, state, delay, command, gameContainer)
{
_model = model;
_global = global;
DominosToPassOut = 12;
}
public SinisterSixMainGameClass(IGamePackageResolver mainContainer,
IEventAggregator aggregator,
BasicData basicData,
TestOptions test,
SinisterSixVMData currentMod,
IMultiplayerSaveState state,
IAsyncDelayer delay,
CommandContainer command,
BasicGameContainer <SinisterSixPlayerItem, SinisterSixSaveInfo> gameContainer,
StandardRollProcesses <EightSidedDice, SinisterSixPlayerItem> 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.BeforeRollingAsync = BeforeRollingAsync;
roller.CanRollAsync = CanRollAsync;
}
public BingoMainGameClass(IGamePackageResolver resolver,
IEventAggregator aggregator,
BasicData basic,
TestOptions test,
BingoVMData model,
IMultiplayerSaveState state,
IAsyncDelayer delay,
CommandContainer command,
RandomGenerator rs,
BasicGameContainer <BingoPlayerItem, BingoSaveInfo> gameContainer
) : base(resolver, aggregator, basic, test, model, state, delay, command, gameContainer)
{
_model = model;
_rs = rs;
}
public LottoDominosMainGameClass(IGamePackageResolver resolver,
IEventAggregator aggregator,
BasicData basic,
TestOptions test,
LottoDominosVMData model,
IMultiplayerSaveState state,
IAsyncDelayer delay,
CommandContainer command,
GameBoardCP gameBoard,
BasicGameContainer <LottoDominosPlayerItem, LottoDominosSaveInfo> gameContainer
) : base(resolver, aggregator, basic, test, model, state, delay, command, gameContainer)
{
_test = test;
_model = model;
_gameBoard = gameBoard;
_gameBoard.MakeMoveAsync = MakeMoveAsync;
}
public RummyDiceMainGameClass(IGamePackageResolver resolver,
IEventAggregator aggregator,
BasicData basic,
TestOptions test,
RummyDiceVMData model,
IMultiplayerSaveState state,
IAsyncDelayer delay,
CommandContainer command,
RummyBoardCP rummyBoard,
BasicGameContainer <RummyDicePlayerItem, RummyDiceSaveInfo> gameContainer
) : base(resolver, aggregator, basic, test, model, state, delay, command, gameContainer)
{
_test = test;
_model = model;
_command = command;
MainBoard1 = rummyBoard;
MainBoard1.SaveRoot = GetSave;
MainBoard1.SelectOneMainAsync = SelectOneMainAsync;
}
public BattleshipMainGameClass(IGamePackageResolver resolver,
IEventAggregator aggregator,
BasicData basic,
TestOptions test,
BattleshipVMData model,
IMultiplayerSaveState state,
IAsyncDelayer delay,
CommandContainer command,
GameBoardCP gameBoard1,
ShipControlCP ships,
BasicGameContainer <BattleshipPlayerItem, BattleshipSaveInfo> gameContainer
) : base(resolver, aggregator, basic, test, model, state, delay, command, gameContainer)
{
_test = test;
_model = model;
_command = command;
GameBoard1 = gameBoard1;
Ships = ships;
}
public CandylandBoardProcesses GameBoard1; //i think
public CandylandMainGameClass(IGamePackageResolver resolver,
IEventAggregator aggregator,
BasicData basic,
TestOptions test,
CandylandVMData model,
IMultiplayerSaveState state,
IAsyncDelayer delay,
CommandContainer command,
DrawShuffleClass <CandylandCardData, CandylandPlayerItem> shuffle,
CandylandBoardProcesses gameBoard1,
BasicGameContainer <CandylandPlayerItem, CandylandSaveInfo> gameContainer
) : base(resolver, aggregator, basic, test, model, state, delay, command, gameContainer)
{
_test = test;
_command = command;
_shuffle = shuffle;
GameBoard1 = gameBoard1;
_shuffle.CurrentPlayer = CurrentPlayer;
_shuffle.AfterDrawingAsync = AfterDrawingAsync;
}
public SnakesAndLaddersMainGameClass(IGamePackageResolver resolver,
IEventAggregator aggregator,
BasicData basic,
TestOptions test,
SnakesAndLaddersVMData model,
IMultiplayerSaveState state,
IAsyncDelayer delay,
CommandContainer command,
StandardRollProcesses <SimpleDice, SnakesAndLaddersPlayerItem> roll,
GameBoardProcesses gameBoard1,
BasicGameContainer <SnakesAndLaddersPlayerItem, SnakesAndLaddersSaveInfo> gameContainer
) : base(resolver, aggregator, basic, test, model, state, delay, command, gameContainer)
{
_test = test;
_model = model;
Roll = roll;
GameBoard1 = gameBoard1;
Roll.AfterRollingAsync = AfterRollingAsync; //hopefully this simple.
roll.CurrentPlayer = GetCurrentPlayer;
GameBoard1.CurrentPlayer = GetCurrentPlayer;
}
public SimpleBoardGameClass(IGamePackageResolver mainContainer,
IEventAggregator aggregator,
BasicData basicData,
TestOptions test,
ISimpleBoardGamesData currentMod,
IMultiplayerSaveState state,
IAsyncDelayer delay,
CommandContainer command,
BasicGameContainer <P, S> gameContainer) : base(
mainContainer,
aggregator,
basicData,
test,
currentMod,
state,
delay,
command,
gameContainer)
{
_currentMod = currentMod;
}
public static bool CanSendMessage <P, S>(this BasicGameContainer <P, S> gameContainer)
where P : class, IPlayerItem, new()
where S : BasicSavedGameClass <P>, new()
{
return(gameContainer.SingleInfo !.CanSendMessage(gameContainer.BasicData));
}
