public TriangleSolitaireMainViewModel(IEventAggregator aggregator,
CommandContainer commandContainer,
IGamePackageResolver resolver
)
{
_aggregator = aggregator;
CommandContainer = commandContainer;
CommandContainer.ExecutingChanged += CommandContainer_ExecutingChanged; //hopefully no problem (?)
DeckPile = resolver.ReplaceObject <DeckObservablePile <SolitaireCard> >();
DeckPile.DeckClickedAsync += DeckPile_DeckClickedAsync;
DeckPile.NeverAutoDisable = true;
DeckPile.SendEnableProcesses(this, () =>
{
if (_mainGame.GameGoing == false)
{
return(false);
}
return(true); //if other logic is needed for deck, put here.
});
_mainGame = resolver.ReplaceObject <TriangleSolitaireMainGameClass>(); //hopefully this works. means you have to really rethink.
Pile1 = new PileObservable <SolitaireCard>(aggregator, commandContainer);
Triangle1 = new TriangleBoard(this, CommandContainer, resolver);
Pile1.Text = "Discard";
Pile1.SendEnableProcesses(this, () => false);
}
public PokerMainViewModel(IEventAggregator aggregator,
CommandContainer commandContainer,
IGamePackageResolver resolver
)
{
GlobalClass.PokerList.Clear(); //can't be brand new that could cause the connection to break too.
_aggregator = aggregator; //this time no new game. just close out when you are done now.
Round = 1;
CommandContainer = commandContainer;
CommandContainer.ExecutingChanged += CommandContainer_ExecutingChanged; //hopefully no problem (?)
DeckPile = resolver.ReplaceObject <DeckObservablePile <PokerCardInfo> >();
DeckPile.DeckClickedAsync += DeckPile_DeckClickedAsync;
DeckPile.NeverAutoDisable = true;
DeckPile.SendEnableProcesses(this, () =>
{
return(!IsRoundOver);
});
Bet1 = new NumberPicker(commandContainer, resolver);
Bet1.SendEnableProcesses(this, () =>
{
return(!BetPlaced);
});
Bet1.LoadNumberList(new CustomBasicList <int>()
{
5, 10, 25
});
Bet1.SelectNumberValue(5); //something else has to set to large (?)
Bet1.ChangedNumberValueAsync += Bet1_ChangedNumberValueAsync;
_mainGame = resolver.ReplaceObject <PokerMainGameClass>(); //hopefully this works. means you have to really rethink.
}
public BlackjackMainViewModel(IEventAggregator aggregator,
CommandContainer commandContainer,
IGamePackageResolver resolver,
StatsClass stats
)
{
//i got around the deckpile by doing resolve. i think this way is better.
_aggregator = aggregator;
CommandContainer = commandContainer;
CommandContainer.ExecutingChanged += CommandContainer_ExecutingChanged; //hopefully no problem (?)
//this means i can no longer ask for it because it needs a new one. otherwise, causes problems.
DeckPile = resolver.ReplaceObject <DeckObservablePile <BlackjackCardInfo> >();
DeckPile.DeckClickedAsync += DeckPile_DeckClickedAsync;
_stats = stats;
IsNotifying = false;
HumanStack = new PlayerStack(commandContainer);
ComputerStack = new PlayerStack(commandContainer);
HumanStack.ProcessLabel(false);
HumanStack.CardSelectedAsync += HumanStack_CardSelectedAsync;
ComputerStack.ProcessLabel(true);
ComputerStack.AlwaysDisabled = true;
HumanStack.SendFunction(() => NeedsAceChoice == false && SelectedYet == false);
Wins = stats.Wins;
Losses = stats.Losses;
Draws = stats.Draws;
IsNotifying = true;
DeckPile.NeverAutoDisable = true;
DeckPile.IsEnabled = false;
DeckPile.SendEnableProcesses(this, () =>
{
return(false); //false this time.
});
_mainGame = resolver.ReplaceObject <BlackjackMainGameClass>(); //hopefully this works. means you have to really rethink.
}
public PokerMainGameClass(ISaveSinglePlayerClass thisState,
IEventAggregator aggregator,
IGamePackageResolver container
)
{
_thisState = thisState;
Aggregator = aggregator;
_saveRoot = container.ReplaceObject <PokerSaveInfo>(); //can't create new one. because if doing that, then anything that needs it won't have it.
}
protected override SolitaireGameClass <VegasSolitaireSaveInfo> GetGame(IGamePackageResolver resolver)
{
VegasSolitaireMainGameClass game;
game = resolver.ReplaceObject <VegasSolitaireMainGameClass>();
game.AddMoney = (() => Money += 5);
game.ResetMoney = (() => Money -= 52);
return(game);
}
public ClockSolitaireMainViewModel(IEventAggregator aggregator,
CommandContainer commandContainer,
IGamePackageResolver resolver
)
{
_aggregator = aggregator;
CommandContainer = commandContainer;
CommandContainer.ExecutingChanged += CommandContainer_ExecutingChanged; //hopefully no problem (?)
DeckPile = resolver.ReplaceObject <DeckObservablePile <SolitaireCard> >();
DeckPile.DeckClickedAsync += DeckPile_DeckClickedAsync;
DeckPile.NeverAutoDisable = true;
DeckPile.SendEnableProcesses(this, () =>
{
return(false); //i think.
});
_mainGame = resolver.ReplaceObject <ClockSolitaireMainGameClass>(); //hopefully this works. means you have to really rethink.
Clock1 = new ClockBoard(this, _mainGame, commandContainer, resolver, _aggregator);
_aggregator.Subscribe(this);
}
public ClockSolitaireMainGameClass(ISaveSinglePlayerClass thisState,
IEventAggregator aggregator,
IGamePackageResolver container
)
{
_thisState = thisState;
Aggregator = aggregator;
SaveRoot = container.ReplaceObject <ClockSolitaireSaveInfo>(); //can't create new one. because if doing that, then anything that needs it won't have it.
SaveRoot.LoadMod(aggregator);
}
public CribbagePatienceMainViewModel(IEventAggregator aggregator,
CommandContainer commandContainer,
IGamePackageResolver resolver
)
{
_aggregator = aggregator;
CommandContainer = commandContainer;
CommandContainer.ExecutingChanged += CommandContainer_ExecutingChanged; //hopefully no problem (?)
DeckPile = resolver.ReplaceObject <DeckObservablePile <CribbageCard> >();
DeckPile.DeckClickedAsync += DeckPile_DeckClickedAsync;
DeckPile.NeverAutoDisable = false;
DeckPile.SendEnableProcesses(this, () =>
{
return(false);
});
Hand1 = new HandObservable <CribbageCard>(commandContainer);
Hand1.Visible = false; //has to be proven true.
Hand1.Maximum = 6;
Hand1.AutoSelect = HandObservable <CribbageCard> .EnumAutoType.SelectAsMany;
_mainGame = resolver.ReplaceObject <CribbagePatienceMainGameClass>(); //hopefully this works. means you have to really rethink.
_aggregator.Subscribe(this);
_mainGame._saveRoot.HandScores = new CustomBasicList <ScoreHandCP>();
3.Times(x =>
{
var tempHand = new ScoreHandCP();
tempHand.HandCategory = (EnumHandCategory)x;
_mainGame._saveRoot.HandScores.Add(tempHand);
});
StartPile = new PileObservable <CribbageCard>(_aggregator, CommandContainer);
StartPile.Text = "Start Card";
StartPile.CurrentOnly = true;
StartPile.SendEnableProcesses(this, () => false);
Scores = new ScoreSummaryCP();
TempCrib = new HandObservable <CribbageCard>(CommandContainer);
TempCrib.Visible = false;
TempCrib.Text = "Crib So Far";
TempCrib.Maximum = 4;
}
public SolitaireBoardGameMainGameClass(ISaveSinglePlayerClass thisState, IEventAggregator aggregator,
ISolitaireBoardEvents solitaireBoard,
IGamePackageResolver mainContainer
)
{
_thisState = thisState;
Aggregator = aggregator;
MainContainer = mainContainer;
_solitaireBoard = solitaireBoard;
_saveRoot = mainContainer.ReplaceObject <SolitaireBoardGameSaveInfo>(); //i think should be this way for now just in case.
LoadBoard();
}
//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.
}
private async Task ReloadGameAsync(Func <BuncoDiceGameSaveInfo, bool, DiceCup <SimpleDice> > loadCup)
{
_saveRoot = await _thisState.RetrieveSinglePlayerGameAsync <BuncoDiceGameSaveInfo>();
_container.ReplaceObject(_saveRoot); //this is now the new object.
_saveRoot.PlayerList.MainContainer = _container; //has to redo that part.
_saveRoot.PlayerList.AutoSaved(_saveRoot !.PlayOrder !); //i think this is needed too.
_cup = loadCup.Invoke(_saveRoot, true);
await Aggregator.SendLoadAsync(); //still needed.
await NewTurnAsync();
}
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 HeapSolitaireMainViewModel(IEventAggregator aggregator,
CommandContainer commandContainer,
IGamePackageResolver resolver
)
{
_aggregator = aggregator;
CommandContainer = commandContainer;
CommandContainer.ExecutingChanged += CommandContainer_ExecutingChanged; //hopefully no problem (?)
DeckPile = resolver.ReplaceObject <DeckObservablePile <HeapSolitaireCardInfo> >();
DeckPile.DeckClickedAsync += DeckPile_DeckClickedAsync;
DeckPile.NeverAutoDisable = true;
_aggregator.Subscribe(this);
DeckPile.SendEnableProcesses(this, () =>
{
return(false);
});
_mainGame = resolver.ReplaceObject <HeapSolitaireMainGameClass>(); //hopefully this works. means you have to really rethink.
Waste1 = new WastePiles(CommandContainer, _aggregator, _mainGame);
Waste1.PileClickedAsync += Waste1_PileClickedAsync;
Main1 = new MainPiles(CommandContainer, _aggregator, _mainGame);
Main1.PileClickedAsync += Main1_PileClickedAsync;
}
public MastermindMainViewModel(IEventAggregator aggregator, CommandContainer commandContainer,
IGamePackageResolver resolver,
LevelClass level
)
{
_aggregator = aggregator;
//looks like can't just ask for the mainboard. because if you do, then when i change the global class, they have the old one (wrong)
LevelChosen = level.LevelChosen;
CommandContainer = commandContainer;
_global = resolver.ReplaceObject <GlobalClass>(); //looks like global has to be replaced before game. otherwise, reference is broken.
CustomColorClass colorClass = new CustomColorClass(_global);
//hopefully won't cause another problem (?)
_mainGame = resolver.ReplaceObject <MastermindMainGameClass>(); //hopefully this works. means you have to really rethink.
MainBoard = resolver.Resolve <GameBoardViewModel>(); //by this time, it will have the proper global class.
//ActiveViewModel = MainBoard;
Color1 = new SimpleEnumPickerVM <EnumColorPossibilities, CirclePieceCP <EnumColorPossibilities> >(commandContainer, colorClass);
Color1.AutoSelectCategory = EnumAutoSelectCategory.AutoEvent;
Color1.IsEnabled = true;
Color1.ItemClickedAsync += Color1_ItemClickedAsync;
}
public PyramidSolitaireMainViewModel(IEventAggregator aggregator,
CommandContainer commandContainer,
IGamePackageResolver resolver
)
{
_aggregator = aggregator;
CommandContainer = commandContainer;
CommandContainer.ExecutingChanged += CommandContainer_ExecutingChanged; //hopefully no problem (?)
DeckPile = resolver.ReplaceObject <DeckObservablePile <SolitaireCard> >();
DeckPile.DeckClickedAsync += DeckPile_DeckClickedAsync;
DeckPile.NeverAutoDisable = true;
aggregator.Subscribe(this);
DeckPile.SendEnableProcesses(this, () =>
{
if (_mainGame.GameGoing == false)
{
return(false);
}
return(true); //if other logic is needed for deck, put here.
});
_mainGame = resolver.ReplaceObject <PyramidSolitaireMainGameClass>(); //hopefully this works. means you have to really rethink.
CurrentPile = new PileObservable <SolitaireCard>(_aggregator, commandContainer);
CurrentPile.SendEnableProcesses(this, () => CurrentPile.PileEmpty() == false);
CurrentPile.Text = "Current";
CurrentPile.CurrentOnly = true;
CurrentPile.PileClickedAsync += CurrentPile_PileClickedAsync;
Discard = new PileObservable <SolitaireCard>(_aggregator, CommandContainer);
Discard.SendEnableProcesses(this, () => Discard.PileEmpty() == false);
Discard.Text = "Discard";
Discard.PileClickedAsync += Discard_PileClickedAsync;
PlayList1 = new PlayList(CommandContainer, aggregator);
PlayList1.SendEnableProcesses(this, () => PlayList1.HasChosenCards());
PlayList1.Visible = true;
GameBoard1 = new TriangleBoard(this, CommandContainer, resolver, _mainGame);
}
public BuncoDiceGameMainGameClass(ISaveSinglePlayerClass thisState,
IEventAggregator aggregator,
IGamePackageResolver container,
RandomGenerator rs,
CommandContainer command,
GlobalClass global
)
{
_thisState = thisState;
Aggregator = aggregator;
_container = container;
_rs = rs;
_command = command;
_global = global;
_saveRoot = container.ReplaceObject <BuncoDiceGameSaveInfo>(); //can't create new one. because if doing that, then anything that needs it won't have it.
}
public BuncoDiceGameMainViewModel(IEventAggregator aggregator,
CommandContainer commandContainer,
IGamePackageResolver resolver,
ISaveSinglePlayerClass state,
GlobalClass global
)
{
_aggregator = aggregator;
_aggregator.Subscribe(this);
CommandContainer = commandContainer;
_resolver = resolver;
_state = state;
_global = global;
CommandContainer.ManuelFinish = true;
CommandContainer.IsExecuting = true; //not sure.
_mainGame = resolver.ReplaceObject <BuncoDiceGameMainGameClass>(); //hopefully this works. means you have to really rethink.
}
protected override SolitaireGameClass <BeleaguredCastleSaveInfo> GetGame(IGamePackageResolver resolver)
{
return(resolver.ReplaceObject <BeleaguredCastleMainGameClass>());
}
protected override SolitaireGameClass <EasyGoSolitaireSaveInfo> GetGame(IGamePackageResolver resolver)
{
return(resolver.ReplaceObject <EasyGoSolitaireMainGameClass>());
}
public SolitaireBoardGameMainViewModel(IEventAggregator aggregator, CommandContainer commandContainer, IGamePackageResolver resolver)
{
_aggregator = aggregator;
CommandContainer = commandContainer;
_mainGame = resolver.ReplaceObject <SolitaireBoardGameMainGameClass>();
}
protected override SolitaireGameClass<RaglanSolitaireSaveInfo> GetGame(IGamePackageResolver resolver)
{
return resolver.ReplaceObject<RaglanSolitaireMainGameClass>();
}
protected override SolitaireGameClass <GrandfathersClockSaveInfo> GetGame(IGamePackageResolver resolver)
{
return(resolver.ReplaceObject <GrandfathersClockMainGameClass>());
}
protected override SolitaireGameClass <EightOffSolitaireSaveInfo> GetGame(IGamePackageResolver resolver)
{
_mainGame = resolver.ReplaceObject <EightOffSolitaireMainGameClass>();
return(_mainGame);
}