async Task IHandleAsync <NextScreenEventModel> .HandleAsync(NextScreenEventModel message)
{
await CloseStartingScreensAsync();
switch (message.Screen)
{
case BeginningClasses.EnumNextScreen.Advanced:
AdvancedScreen = MainContainer.Resolve <AdvancedOptionsViewModel>();
await LoadScreenAsync(AdvancedScreen);
break;
case BeginningClasses.EnumNextScreen.Cards:
CardsScreen = MainContainer.Resolve <CardsPlayerViewModel>();
await LoadScreenAsync(CardsScreen);
break;
case BeginningClasses.EnumNextScreen.Finished:
await StartNewGameAsync(); //hopefully this simple.
//if there is anything else that has to happen at this stage, this can do it.
break;
default:
throw new BasicBlankException("Next screen not supported");
}
}
private async Task LoadGameScreenAsync()
{
if (_mainGame == null)
{
_mainGame = MainContainer.Resolve <IBasicGameProcesses <P> >();
}
if (_mainGame.CanMakeMainOptionsVisibleAtBeginning)
{
ClearSubscriptions(); //try this too.
await StartNewGameAsync();
if (_test.AlwaysNewGame)
{
NewGameScreen = MainContainer.Resolve <INewGameVM>();
await LoadScreenAsync(NewGameScreen);
}
return;
}
//only host or single player game gets to this part.
await GetStartingScreenAsync();
if (_test.AlwaysNewGame)
{
NewGameScreen = MainContainer.Resolve <INewGameVM>();
await LoadScreenAsync(NewGameScreen);
}
}
private int BonusPoints(RackoPlayerItem thisPlayer)
{
RummyProcesses <EnumSuitList, EnumSuitList, RackoCardInformation> thisInfo = new RummyProcesses <EnumSuitList, EnumSuitList, RackoCardInformation>();
thisInfo.HasSecond = false;
thisInfo.HasWild = false;
thisInfo.NeedMatch = false; //try this too.
thisInfo.LowNumber = 1;
RackoDeckCount temps = MainContainer.Resolve <RackoDeckCount>();
thisInfo.HighNumber = temps.GetDeckCount();
DeckRegularDict <RackoCardInformation> tempCol = thisPlayer.MainHandList.ToRegularDeckDict();
var newColls = thisInfo.WhatNewRummy(tempCol, 6, RummyProcesses <EnumSuitList, EnumSuitList, RackoCardInformation> .EnumRummyType.Runs, true);
if (newColls.Count > 0)
{
return(400);
}
newColls = thisInfo.WhatNewRummy(tempCol, 5, RummyProcesses <EnumSuitList, EnumSuitList, RackoCardInformation> .EnumRummyType.Runs, true);
if (newColls.Count > 0)
{
return(200);
}
newColls = thisInfo.WhatNewRummy(tempCol, 4, RummyProcesses <EnumSuitList, EnumSuitList, RackoCardInformation> .EnumRummyType.Runs, true);
if (newColls.Count > 0)
{
return(100);
}
newColls = thisInfo.WhatNewRummy(tempCol, 3, RummyProcesses <EnumSuitList, EnumSuitList, RackoCardInformation> .EnumRummyType.Runs, true);
if (newColls.Count > 0)
{
return(50);
}
return(0);
}
async Task IHandleAsync <RestoreEventModel> .HandleAsync(RestoreEventModel message)
{
await RestoreAsync();
IRestoreMultiPlayerGame restore = MainContainer.Resolve <IRestoreMultiPlayerGame>();
await restore.RestoreGameAsync();
}
async Task IRestoreNM.RestoreMessageAsync(string payLoad)
{
await RestoreAsync();
IClientUpdateGame client = MainContainer.Resolve <IClientUpdateGame>();
await client.UpdateGameAsync(payLoad);
}
public override async Task SetUpGameAsync(bool isBeginning)
{
LoadControls();
if (FinishUpAsync == null)
{
throw new BasicBlankException("The loader never set the finish up code. Rethink");
}
if (BasicData.MultiPlayer == false)
{
SaveRoot.Level = EnumLevel.Hard;
IShuffleTiles tiles = MainContainer.Resolve <IShuffleTiles>();
await tiles.StartShufflingAsync(this);
}
else
{
SaveRoot.Level = EnumLevel.None;
SaveRoot.CanStart = false;
_model.PlayerWon = "";
await LoadStartOptionsAsync();
}
//hopefully will be this simple this time (?)
await FinishUpAsync(isBeginning);
}
protected override Task PrepNewGameAsync()
{
IEraseColors erase = MainContainer.Resolve <IEraseColors>();
erase.EraseColors();
return(Task.CompletedTask);
}
//the old screens should be closed first before this runs.
//private async Task GetNextScreenAsync()
//{
// //this should figure out the first screen or future screens. in this case, this works well.
// ThreeLetterFunSaveInfo saveroot = MainContainer.Resolve<ThreeLetterFunSaveInfo>();
// if (saveroot.CanStart)
// {
// //this will load the main screen now.
// await StartNewGameAsync();
// return; //hopefully other rethinking is not required. if so, do rethink.
// }
// if (saveroot.Level == EnumLevel.None)
// {
// //this means needs to load the first screen. you have to first choose level.
// FirstScreen = MainContainer.Resolve<FirstOptionViewModel>();
// await LoadScreenAsync(FirstScreen);
// return;
// }
//}
//decided that to begin with, if you close out before choosing options, you start over again.
//otherwise, a person would have to remember what they chose previously.
protected override async Task GetStartingScreenAsync()
{
//await GetNextScreenAsync();
FirstScreen = MainContainer.Resolve <FirstOptionViewModel>();
await LoadScreenAsync(FirstScreen);
}
private async Task LoadActionScreenAsync(ActionContainer actionContainer)
{
if (ActionScreen != null)
{
throw new BasicBlankException("Previous action was not loaded. Rethink");
}
await CloseMainAsync();
await CloseKeeperScreenAsync();
//much harder to figure out which screen to load.
switch (actionContainer.ActionCategory)
{
case EnumActionCategory.None:
break;
case EnumActionCategory.Rules:
break;
case EnumActionCategory.Directions:
break;
case EnumActionCategory.DoAgain:
break;
case EnumActionCategory.TradeHands:
break;
case EnumActionCategory.UseTake:
break;
case EnumActionCategory.Everybody1:
break;
case EnumActionCategory.DrawUse:
break;
case EnumActionCategory.FirstRandom:
break;
default:
break;
}
ActionScreen = actionContainer.ActionCategory switch
{
EnumActionCategory.Rules => MainContainer.Resolve <ActionDiscardRulesViewModel>(),
EnumActionCategory.Directions => MainContainer.Resolve <ActionDirectionViewModel>(),
EnumActionCategory.DoAgain => MainContainer.Resolve <ActionDoAgainViewModel>(),
EnumActionCategory.DrawUse => MainContainer.Resolve <ActionDrawUseViewModel>(),
EnumActionCategory.Everybody1 => MainContainer.Resolve <ActionEverybodyGetsOneViewModel>(),
EnumActionCategory.FirstRandom => MainContainer.Resolve <ActionFirstCardRandomViewModel>(),
EnumActionCategory.TradeHands => MainContainer.Resolve <ActionTradeHandsViewModel>(),
EnumActionCategory.UseTake => MainContainer.Resolve <ActionTakeUseViewModel>(),
_ => throw new BasicBlankException("Cannot figure out action screen. Rethink")
};
await LoadScreenAsync(ActionScreen);
RefreshEnables();
}
async Task IHandleAsync <StartAutoresumeMultiplayerGameEventModel> .HandleAsync(StartAutoresumeMultiplayerGameEventModel message)
{
await CloseOpenScreenAsync("Start autoresume multiplayer game");
//await LoadGameScreenAsync(); //forgot here too.
IStartMultiPlayerGame <P> starts = MainContainer.Resolve <IStartMultiPlayerGame <P> >();
await starts.LoadSavedGameAsync();
}
protected override async Task OpenStartingScreensAsync()
{
OpeningScreen = MainContainer.Resolve <SpiderSolitaireOpeningViewModel>(); //i think has to be this way so its fresh everytime.
await LoadScreenAsync(OpeningScreen); //try this way.
await ShowNewGameAsync();
FinishInit();
}
async Task IHandleAsync <StartMultiplayerGameEventModel <P> > .HandleAsync(StartMultiplayerGameEventModel <P> message)
{
await CloseOpenScreenAsync("Start new multiplayer game");
//await LoadGameScreenAsync(); //forgot here too.
IStartMultiPlayerGame <P> starts = MainContainer.Resolve <IStartMultiPlayerGame <P> >();
await starts.LoadNewGameAsync(message.PlayerList);
}
//private static async Task<bool> TryActivateItemAsync(object parentViewModel, IUIView? parentViewScreen, object childViewModel)
//{
// if (UIPlatform.ViewLocator is null)
// return false;
// if (UIPlatform.ScreenLoader is null)
// return false;
// IUIView childview = await UIPlatform.ViewLocator.LocateViewAsync(childViewModel)!;
// if (childview == null)
// throw new BasicBlankException("No view was found when trying to active an item. Rethink");
// if (parentViewScreen == null)
// throw new BasicBlankException("Has to have an active view in order to activate another screen");
// //we need a method that will do the rest of what is needed. probably another interface.
// await UIPlatform.ScreenLoader.LoadScreenAsync(parentViewModel, parentViewScreen, childViewModel, childview);
// if (childViewModel is IScreen screens)
// {
// if (parentViewModel is IHaveActiveViewModel active)
// active.ActiveViewModel = screens;
// await screens.ActivateAsync(childview);
// }
// else
// {
// await childview.TryActivateAsync(); //to do extra things whatever is needed that is actually async.
// //should not activate twice.
// }
// return true;
//}
//private async Task ExperimentAsync(object vm)
//{
// //this time, has to do lots of copy/paste to see what the problem is this time.
// //return ConductorBehavior.TryActivateItemAsync(this, MainScreen, viewModel!);
// await TryActivateItemAsync(this, MainScreen, vm);
//}
protected async Task ShowNewGameAsync()
{
NewGameVM = MainContainer.Resolve <INewGameVM>();
//await ExperimentAsync(NewGameVM);
await LoadScreenAsync(NewGameVM);
}
protected async Task ShowNewGameAsync()
{
NewGameScreen = MainContainer.Resolve <INewGameVM>();
await LoadScreenAsync(NewGameScreen);
CommandContainer.IsExecuting = true;
CommandContainer.ManuelFinish = true;
}
private void LoadControls()
{
if (IsLoaded == true)
{
return;
}
_graphics = MainContainer.Resolve <TicTacToeGraphicsCP>();
IsLoaded = true; //i think needs to be here.
}
Task IHandleAsync <NewRoundEventModel> .HandleAsync(NewRoundEventModel message)
{
if (TempScreen != null)
{
throw new BasicBlankException("The screen was never closed out. Rethink");
}
TempScreen = MainContainer.Resolve <BuncoNewRoundViewModel>();
return(LoadScreenAsync(TempScreen));
}
private async Task LoadBidAsync()
{
if (BidScreen != null)
{
await CloseSpecificChildAsync(BidScreen);
}
BidScreen = MainContainer.Resolve <PickelBidViewModel>();
await LoadScreenAsync(BidScreen);
}
private async Task LoadGenderAsync()
{
if (GenderScreen != null)
{
throw new BasicBlankException("Cannot load gender because its already there. Rethink");
}
GenderScreen = MainContainer.Resolve <ChooseGenderViewModel>();
await LoadScreenAsync(GenderScreen);
}
//still needs to be able to override it.
//so for game of life, has the option for another screen.
protected override async Task GetStartingScreenAsync()
{
if (ColorScreen != null)
{
await CloseSpecificChildAsync(ColorScreen);
}
ColorScreen = MainContainer.Resolve <IBeginningColorViewModel>();
await LoadScreenAsync(ColorScreen);
}
async Task INewGameNM.NewGameReceivedAsync(string data)
{
if (OpeningScreen != null)
{
throw new BasicBlankException("The opening screen should have been closed. Rethink");
}
await RestoreAsync(); //take a risk here.
IClientUpdateGame clientUpdate = MainContainer.Resolve <IClientUpdateGame>();
await clientUpdate.UpdateGameAsync(data);
}
private void LoadControls()
{
if (IsLoaded == true)
{
return;
}
ScoreSheets = MainContainer.Resolve <BowlingScoresCP>();
DiceBoard = MainContainer.Resolve <BowlingDiceSet>();
DiceBoard.FirstLoad(); //forgot this.
IsLoaded = true; //i think needs to be here.
}
async Task IHandleAsync <RoundOverEventModel> .HandleAsync(RoundOverEventModel message)
{
NewRoundScreen = MainContainer.Resolve <INewRoundVM>();
await LoadScreenAsync(NewRoundScreen);
CommandContainer.ManuelFinish = true;
CommandContainer.IsExecuting = true;
//i think this may be it (?)
//CommandContainer.ManuelFinish = false;
//CommandContainer.IsExecuting = false;
}
public async Task LoadBidScreenAsync()
{
if (BidScreen != null)
{
return;
}
await CloseMainAsync("Already closed main to load bidding. Rethink");
BidScreen = MainContainer.Resolve <RageBiddingViewModel>();
await LoadScreenAsync(BidScreen);
}
private void SetObjects()
{
if (_deckInfo != null)
{
return;
}
PopulateContainer(this);
_deckInfo = MainContainer !.Resolve <ThreeLetterFunDeckInfo>(); //need the full one.
_thisGlobal = MainContainer.Resolve <GlobalHelpers>();
_mainGame = MainContainer.Resolve <ThreeLetterFunMainGameClass>();
}
public async Task LoadColorScreenAsync()
{
if (ColorScreen != null)
{
return;
}
await CloseMainAsync("Already closed main to load colors. Rethink");
ColorScreen = MainContainer.Resolve <RageColorViewModel>();
await LoadScreenAsync(ColorScreen);
}
private async Task LoadMainGameAsync()
{
if (FaceoffScreen == null)
{
throw new BasicBlankException("Faceoff should have been loaded first. Rethink");
}
await CloseSpecificChildAsync(FaceoffScreen);
FaceoffScreen = null;
MainVM = MainContainer.Resolve <BladesOfSteelMainViewModel>();
await LoadScreenAsync(MainVM);
}
private async Task LoadMainScreenAsync()
{
if (FirstScreen == null)
{
return; //because main screen is already loaded.
}
await CloseSpecificChildAsync(FirstScreen);
FirstScreen = null;
MainVM = MainContainer.Resolve <GolfCardGameMainViewModel>();
await LoadScreenAsync(MainVM);
}
protected override async Task GetStartingScreenAsync()
{
LifeBoardGameSaveInfo saveRoot = MainContainer.Resolve <LifeBoardGameSaveInfo>();
if (saveRoot.GameStatus == EnumWhatStatus.NeedChooseGender)
{
await LoadGenderAsync();
return;
}
await base.GetStartingScreenAsync();
}
public int GetDeckCount()
{
if (_deckCount == null)
{
PopulateContainer(this);
_deckCount = MainContainer !.Resolve <IDeckCount>(); //i think
if (MainContainer.RegistrationExist <INewCard <D> >())
{
_newCard = MainContainer.Resolve <INewCard <D> >();
}
}
return(_deckCount.GetDeckCount());
}
async Task IHandleAsync <NewRoundEventModel> .HandleAsync(NewRoundEventModel message)
{
ClearSubscriptions();
await CloseMainAsync("The main screen should have been not null when choosing new round. Rethink");
await CloseRoundAsync();
await NewGameOrRoundRequestedAsync();
//await LoadGameScreenAsync();
IRequestNewGameRound gameRound = MainContainer.Resolve <IRequestNewGameRound>();
await gameRound.RequestNewRoundAsync();
//hint: either another message or somebody else would send the same message for the client.
}
