public static DeckRegularDict <FluxxCardInformation> CardsForTaxation(FluxxGameContainer gameContainer)
{
int extras = gameContainer.IncreaseAmount();
int howMany = extras + 1;
return(gameContainer.SingleInfo !.MainHandList.GetRandomList(true, howMany).ToRegularDeckDict()); //i think you do need to remove previous.
}
public PlayViewModel(CommandContainer commandContainer, IPlayProcesses playProcesses, FluxxMainGameClass mainGame, FluxxGameContainer gameContainer, FluxxVMData model) : base(commandContainer)
{
_playProcesses = playProcesses;
_mainGame = mainGame;
_gameContainer = gameContainer;
_model = model;
}
public FluxxMainViewModel(CommandContainer commandContainer,
FluxxMainGameClass mainGame,
FluxxVMData viewModel,
BasicData basicData,
TestOptions test,
IGamePackageResolver resolver,
FluxxGameContainer gameContainer,
IDiscardProcesses discardProcesses,
IAnalyzeProcesses analyzeQueProcesses,
KeeperContainer keeperContainer,
FluxxDelegates delegates
)
: base(commandContainer, mainGame, viewModel, basicData, test, resolver)
{
_mainGame = mainGame;
_model = viewModel;
_resolver = resolver;
_gameContainer = gameContainer;
_discardProcesses = discardProcesses;
_analyzeQueProcesses = analyzeQueProcesses;
_keeperContainer = keeperContainer;
_delegates = delegates;
_model.Deck1.NeverAutoDisable = true;
_gameContainer.LoadGiveAsync = LoadGiveAsync;
_gameContainer.LoadPlayAsync = LoadPlayAsync;
_model.Keeper1.ConsiderSelectOneAsync += OnConsiderSelectOneCardAsync;
_model.Goal1.ConsiderSelectOneAsync += OnConsiderSelectOneCardAsync;
}
public ActionEverybodyGetsOneViewModel(FluxxGameContainer gameContainer,
ActionContainer actionContainer,
KeeperContainer keeperContainer,
FluxxDelegates delegates,
IFluxxEvent fluxxEvent,
BasicActionLogic basicActionLogic) : base(gameContainer, actionContainer, keeperContainer, delegates, fluxxEvent, basicActionLogic)
{
}
public ActionFirstCardRandomViewModel(FluxxGameContainer gameContainer,
ActionContainer actionContainer,
KeeperContainer keeperContainer,
FluxxDelegates delegates,
IFluxxEvent fluxxEvent,
BasicActionLogic basicActionLogic) : base(gameContainer, actionContainer, keeperContainer, delegates, fluxxEvent, basicActionLogic)
{
}
public static DeckRegularDict <FluxxCardInformation> CardsToDiscardFromHand(FluxxGameContainer gameContainer, int howMany)
{
if (howMany <= 0)
{
throw new BasicBlankException("Must discard at least one card from hand");
}
return(gameContainer.SingleInfo !.MainHandList.GetRandomList(false, howMany).ToRegularDeckDict());
}
public ShowActionProcesses(ActionContainer actionContainer,
BasicActionLogic basicActionLogic,
FluxxGameContainer gameContainer
)
{
_actionContainer = actionContainer;
_basicActionLogic = basicActionLogic;
_gameContainer = gameContainer;
}
public ActionDiscardRulesViewModel(FluxxGameContainer gameContainer,
ActionContainer actionContainer,
KeeperContainer keeperContainer,
FluxxDelegates delegates,
IFluxxEvent fluxxEvent,
BasicActionLogic basicActionLogic) : base(gameContainer, actionContainer, keeperContainer, delegates, fluxxEvent, basicActionLogic)
{
RulesToDiscard = actionContainer.RulesToDiscard;
}
public static DeckRegularDict <FluxxCardInformation> DiscardKeepers(FluxxGameContainer gameContainer, int howMany)
{
if (howMany <= 0)
{
throw new BasicBlankException("Must discard at least one keeper");
}
var firsts = gameContainer.SingleInfo !.KeeperList.GetRandomList(false, howMany);
return(new DeckRegularDict <FluxxCardInformation>(firsts));
}
public FinalKeeperProcesses(FluxxGameContainer gameContainer,
IAnalyzeProcesses analyzeProcesses,
FluxxDelegates delegates,
IDiscardProcesses discardProcesses
)
{
_gameContainer = gameContainer;
_analyzeProcesses = analyzeProcesses;
_delegates = delegates;
_discardProcesses = discardProcesses;
}
public LoadActionProcesses(ActionContainer actionContainer,
FluxxVMData model,
BasicActionLogic basicActionLogic,
FluxxGameContainer gameContainer
)
{
_actionContainer = actionContainer;
_model = model;
_basicActionLogic = basicActionLogic;
_gameContainer = gameContainer;
}
public GiveViewModel(
CommandContainer commandContainer,
FluxxVMData model,
FluxxGameContainer gameContainer,
IGiveTaxationProcesses processes
) : base(commandContainer)
{
_model = model;
_gameContainer = gameContainer;
_processes = processes;
}
public static CustomBasicList <int> SimplifyRules(FluxxGameContainer gameContainer, ActionContainer actionContainer)
{
var maxs = actionContainer.RulesToDiscard;
var howMany = gameContainer.Random.GetRandomNumber(maxs, 0); // can even choose 0 to discard
if (howMany == 0)
{
return(new CustomBasicList <int>());
}
var tempList = actionContainer.GetTempRuleList();
return(tempList.GetRandomList(false, howMany).ToCustomBasicList());
}
public void LoadControls(FluxxGameContainer gameContainer)
{
Text = "Rule Information";
_ruleList = gameContainer.SaveRoot !.RuleList;
_ruleList.CollectionChanged += RuleListChange;
_stack = new StackLayout();
Grid grid = new Grid();
WidthRequest = 200;
SetUpMarginsOnParentControl(_stack); //i think.
grid.Children.Add(ThisDraw);
grid.Children.Add(_stack);
Content = grid;
LoadRules();
}
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;
}
public static Tuple <KeeperPlayer, KeeperPlayer> ExchangeKeepers(FluxxGameContainer gameContainer)
{
KeeperPlayer keeperFrom;
keeperFrom = new KeeperPlayer()
{
Player = gameContainer.WhoTurn, Card = (int)gameContainer.SingleInfo !.KeeperList.GetRandomItem().Deck
};
var tempList = gameContainer.PlayerList !.AllPlayersExceptForCurrent();
var tempPlayer = tempList.GetRandomItem();
KeeperPlayer KeeperTo = new KeeperPlayer()
{
Player = tempPlayer.Id, Card = (int)tempPlayer.KeeperList.GetRandomItem().Deck
};
return(new Tuple <KeeperPlayer, KeeperPlayer>(keeperFrom, KeeperTo));
}
public static KeeperPlayer KeeperToStealTrash(FluxxGameContainer gameContainer, bool isTrashed)
{
var tempList = gameContainer.PlayerList.Where(items => items.KeeperList.Count > 0).ToCustomBasicList();
if (isTrashed == false)
{
tempList.RemoveSpecificItem(gameContainer.SingleInfo !);
}
if (tempList.Count == 0)
{
throw new BasicBlankException("There are no keepers to trash or steal");
}
var thisPlayer = tempList.GetRandomItem();
return(new KeeperPlayer {
Card = (int)thisPlayer.KeeperList.GetRandomItem().Deck, Player = thisPlayer.Id
});
}
//if discard or empty requires play, then rethink or overflow errors.
public PlayProcesses(FluxxGameContainer gameContainer,
FluxxVMData model,
IAnalyzeProcesses analyzeProcesses,
IDiscardProcesses discardProcesses,
IEmptyTrashProcesses emptyTrashProcesses,
ActionContainer actionContainer,
IShowActionProcesses showActionProcesses
)
{
_gameContainer = gameContainer;
_model = model;
_analyzeProcesses = analyzeProcesses;
_discardProcesses = discardProcesses;
_emptyTrashProcesses = emptyTrashProcesses;
_actionContainer = actionContainer;
_showActionProcesses = showActionProcesses;
_gameContainer.PlayCardAsync = PlayCardAsync;
}
public BasicActionScreen(FluxxGameContainer gameContainer,
ActionContainer actionContainer,
KeeperContainer keeperContainer,
FluxxDelegates delegates,
IFluxxEvent fluxxEvent,
BasicActionLogic basicActionLogic
)
{
GameContainer = gameContainer;
ActionContainer = actionContainer;
_keeperContainer = keeperContainer;
_delegates = delegates;
FluxxEvent = fluxxEvent;
BasicActionLogic = basicActionLogic;
CommandContainer = gameContainer.Command;
ActionContainer.PropertyChanged += ActionContainer_PropertyChanged;
ButtonChooseCardVisible = ActionContainer.ButtonChooseCardVisible;
}
public static void LoadSavedGame(this ActionContainer actionContainer, FluxxGameContainer gameContainer)
{
gameContainer.SingleInfo = gameContainer.PlayerList !.GetSelf();
actionContainer.YourCards !.HandList = gameContainer.SingleInfo.MainHandList;
actionContainer.YourKeepers !.HandList = gameContainer.SingleInfo.KeeperList;
gameContainer.SingleInfo = gameContainer.PlayerList.GetWhoPlayer();
if (gameContainer.CurrentAction == null)
{
return;
}
if (gameContainer.CurrentAction.Deck == EnumActionMain.UseWhatYouTake && gameContainer.SaveRoot !.SavedActionData.SelectedIndex > -1)
{
BasicActionLogic logic = gameContainer.Resolver.Resolve <BasicActionLogic>();
logic.SavedPlayers();
actionContainer.IndexPlayer = gameContainer.SaveRoot.SavedActionData.SelectedIndex;
if (actionContainer.IndexPlayer == -1)
{
throw new BasicBlankException("Rethink for reloading game");
}
actionContainer.Player1 !.SelectSpecificItem(actionContainer.IndexPlayer);
}
}
public FinalRuleProcesses(FluxxGameContainer gameContainer, IAnalyzeProcesses processes)
{
_gameContainer = gameContainer;
_processes = processes;
}
public KeeperShowView(FluxxGameContainer gameContainer,
KeeperContainer keeperContainer,
ActionContainer actionContainer,
FluxxVMData model) : base(gameContainer, keeperContainer, actionContainer, model)
{
}
public EmptyTrashProcesses(FluxxGameContainer gameContainer, FluxxVMData model, IAnalyzeProcesses processes)
{
_gameContainer = gameContainer;
_model = model;
_processes = processes;
}
public AnalyzeProcesses(FluxxGameContainer gameContainer)
{
_gameContainer = gameContainer;
}
public GiveTaxationProcesses(FluxxGameContainer gameContainer, IAnalyzeProcesses processes)
{
_gameContainer = gameContainer;
_processes = processes;
}
public DrawUseProcesses(FluxxGameContainer gameContainer, IAnalyzeProcesses analyzeProcesses)
{
_gameContainer = gameContainer;
_analyzeProcesses = analyzeProcesses;
}
public KeeperTrashViewModel(FluxxGameContainer gameContainer, KeeperContainer keeperContainer, IFluxxEvent fluxxEvent) : base(gameContainer, keeperContainer, fluxxEvent)
{
}
public KeeperShowViewModel(FluxxGameContainer gameContainer, KeeperContainer keeperContainer, IFluxxEvent fluxxEvent) : base(gameContainer, keeperContainer)
{
_fluxxEvent = fluxxEvent;
}
public BasicActionLogic(FluxxGameContainer gameContainer, ActionContainer actionContainer, FluxxDelegates delegates)
{
_gameContainer = gameContainer;
_actionContainer = actionContainer;
_delegates = delegates;
}
public RotateTradeHandProcesses(FluxxGameContainer gameContainer, IAnalyzeProcesses processes, ActionContainer actionContainer)
{
_gameContainer = gameContainer;
_processes = processes;
_actionContainer = actionContainer;
}
