コード例 #1
0
        public IActionResult CreateNewGame(long UserId, GameTypeEnum GameType)
        {
            var cntTask = _gameRepo.UserGamesPlayedToday(UserId);
            var cnt     = cntTask.Result;

            if (cnt != 0)
            {
                return(new BadRequestObjectResult(new ShakeException(ShakeError.AlreadyPlayedToday, "You have already played a game today.")));
            }


            var gameTask = _gameRepo.NewGame(UserId, GameType);

            gameTask.Wait();
            var gameId = gameTask.Result.Single();

            var success = _wallets.SubtractABuck(UserId).Result;

            if (!success)
            {
                return(new NoContentResult());
            }

            var getgameTask = _gameRepo.GetGameById(gameId);

            getgameTask.Wait();
            var gameObj = getgameTask.Result;

            return(Ok(gameObj));
        }
コード例 #2
0
        /// <see cref="IMultiplayerService.CreateNewGame"/>
        public void CreateNewGame(string mapFile, GameTypeEnum gameType, GameSpeedEnum gameSpeed)
        {
            /// TODO: this is only a PROTOTYPE implementation!
            this.scenarioManager.OpenScenario(mapFile);
            this.scenarioManager.ActiveScenario.Map.FinalizeMap();

            this.playerManager = new PlayerManager(this.scenarioManager.ActiveScenario);
            this.playerManager[0].ConnectRandomPlayer(RaceEnum.Terran);
            this.playerManager[1].ConnectRandomPlayer(RaceEnum.Terran);
            this.playerManager[2].ConnectRandomPlayer(RaceEnum.Terran);
            this.playerManager[3].ConnectRandomPlayer(RaceEnum.Terran);
            this.playerManager.Lock();

            this.selectionManager.Reset(this.playerManager[0].Player);
            this.fogOfWarBC.StartFogOfWar(this.playerManager[0].Player);
            this.mapWindowBC.ScrollTo(this.playerManager[0].StartPosition);
            this.commandManager.NewCommand += this.PostCommand;

            this.commandDispatcher  = new CommandDispatcher();
            this.triggeredScheduler = new TriggeredScheduler(1000 / (int)gameSpeed);
            this.triggeredScheduler.AddScheduledFunction(this.pathfinder.Update);
            this.triggeredScheduler.AddScheduledFunction(this.ExecuteCommands);
            this.triggeredScheduler.AddScheduledFunction(this.scenarioManager.ActiveScenario.Update);
            this.triggeredScheduler.AddScheduledFunction(this.commandManager.Update);
            this.triggeredScheduler.AddScheduledFunction(this.fogOfWarBC.ExecuteUpdateIteration);
            this.triggeredScheduler.AddScheduledFunction(() => { if (this.GameUpdated != null)
                                                                 {
                                                                     this.GameUpdated();
                                                                 }
                                                         });
            this.testDssTaskCanFinishEvt = new ManualResetEvent(false);
            this.dssTask = this.taskManager.StartTask(this.TestDssTaskMethod, "DssThread");
        }
コード例 #3
0
        // methods
        // ----------
        // create initial game state
        // ----------
        public static void createGameState(GameTypeEnum gameType)
        {
            GameType   = gameType;
            GameStatus = GameStatusEnum.InProgress;

            // initialize decks
            ActiveDeck       = new ActiveDeck();
            ActiveDeckCount  = "0";
            DiscardDeck      = new DiscardDeck();
            DiscardDeckCount = "0";

            // initialise actors
            TableDealer          = createDealer();
            DealerHandVisibility = Visibility.Hidden;

            NextGameControlsVisibility   = Visibility.Hidden;
            ActiveGameControlsVisibility = Visibility.Visible;

            // initialise players list
            Players         = new List <Player>();
            PlayerTurnIndex = 0;

            // clear all event delegates
            clearEventDelegates();
        }
コード例 #4
0
 public static Game GetByEnum(GameTypeEnum gameEnum)
 {
     foreach (Game game in GAMES)
     {
         if (game.GameType == gameEnum)
         {
             return(game);
         }
     }
     return(null);
 }
コード例 #5
0
        public static Game NewGameByType(GameTypeEnum gameType, GameState state)
        {
            switch (gameType)
            {
            case GameTypeEnum.Battle:
                return(new BattleGame(state));

            default:
                GD.Print("NewGameByType: invalid gameType: " + gameType);
                return(null);
            }
        }
コード例 #6
0
    private RoomInfo GetRoom(GameTypeEnum GameType)
    {
        var rooms             = _Loader.GetRoomList();
        var orderByDescending = rooms.Where(a => !a.privateRoom && ValidateRoom(a) && a.playerCount < 8 && (a.version == bs.settings.mpVersion)).OrderByDescending(a => a.playerCount);

        if (android && !Application.isEditor)
        {
            orderByDescending = orderByDescending.OrderBy(a => a.maxPlayers);
        }
        RoomInfo firstOrDefault = orderByDescending.FirstOrDefault(a => a.gameType == (GameType));

        return(firstOrDefault);
    }
コード例 #7
0
        public void StartNewGame(GameTypeEnum gameType)
        {
            if (games.ContainsKey(gameType))
            {
                games[gameType].End();
                games[gameType].QueueFree();
                games.Remove(gameType);
            }

            games[gameType] = GameConstants.NewGameByType(gameType, state);
            AddChild(games[gameType]);
            games[gameType].Start();
            activeGame = gameType;
        }
コード例 #8
0
        public Table(
            string id,
            string name,
            GameTypeEnum gameType,
            Player owner)
        {
            const int INITIAL_CAPACITY = 10;

            Players  = new List <Player>(INITIAL_CAPACITY);
            History  = new List <TableHistory>(INITIAL_CAPACITY);
            ID       = id;
            Name     = name;
            GameType = gameType;
            Owner    = owner;
            State    = TableState.Waiting;
        }
コード例 #9
0
        /*
         * Constructor.
         * <param name="gameId">game name</param>
         * <param name="steam">steam id</param>
         * <param name="gameDir">game pathname below user dir</param>
         * <param name="scriptFile">name of the script file containing mod entries</param>
         */
        public Game(GameTypeEnum gameType, string gameId, string steam, string gameDir, string scriptFile = "user.script.txt")
        {
            GameType = gameType;
            Id       = gameId;
            steamId  = steam;
            UserDir  = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData),
                                    "The Creative Assembly", gameDir);
            ScriptFilename = scriptFile;
            DefaultPfhType = "PFH3";

            retrievers = new RetrieveLocation[] {
                delegate() { return(gameDirectory); },
                delegate() { return(GetInstallLocation(WOW_NODE)); },
                delegate() { return(GetInstallLocation(WIN_NODE)); }
            };
        }
コード例 #10
0
        public async Task <IEnumerable <long> > NewGame(long UserId, GameTypeEnum type)
        {
            var obj = new
            {
                UserId = UserId,
                gType  = (int)type,
                Year   = DateTime.Now.Year,
                Day    = DateTime.Now.DayOfYear
            };

            var insSql = $@"
                Insert Into Games(TypeId,UserId,Year,Day)
                Values(@gType, @UserId, @Year, @Day);
                SELECT CAST(SCOPE_IDENTITY() as bigint)       
            ";

            return(await _conn.QueryAsync <long>(insSql, obj));
        }
コード例 #11
0
        void Load(GameTypeEnum game)
        {
            if (_gameTableDefinitions.ContainsKey(game))
            {
                return;
            }

            string path = DirectoryHelper.SchemaDirectory + "\\" + GameInformationFactory.GetGameById(game).ShortID + "_schema.json";   // Try local copy first

            if (!File.Exists(path))
            {
                path = "Resources\\Schemas\\" + GameInformationFactory.GetGameById(game).ShortID + "_schema.json";
            }

            var content = LoadSchemaFile(path);

            if (content != null)
            {
                _gameTableDefinitions.Add(game, content);
            }

            path = DirectoryHelper.SchemaDirectory + "\\" + GameInformationFactory.GetGameById(game).ShortID + "_AnimMetaDataSchema.json"; // Try local copy first
            if (!File.Exists(path))
            {
                var allResource = GetResourceNames();

                var resourceFileName = GameInformationFactory.GetGameById(game).ShortID + "_AnimMetaDataSchema.json";
                var entry            = allResource.FirstOrDefault(x => x.Key.ToString().Contains(resourceFileName, StringComparison.InvariantCultureIgnoreCase));
                if (entry.Key != null)
                {
                    using var resourceReader = new StreamReader(entry.Value as Stream);
                    var resourceContent = resourceReader.ReadToEnd();
                    content = LoadSchemaFileFromContent(resourceContent);
                }
            }
            else
            {
                content = LoadSchemaFile(path);
            }
            if (content != null)
            {
                _gameAnimMetaDefinitions.Add(game, content);
            }
        }
コード例 #12
0
    public void HostRoomWindow()
    {
        SetupWindow(800, 600);
        gui.BeginHorizontal();
        gui.BeginVertical();
        bool startButton = Button("Start");

        if (Button("Load Map from url"))
        {
            LoadMapFromUrl();
        }

        Label("Room Name:");
        room.name        = gui.TextField(room.name, 20);
        room.privateRoom = Toggle(room.privateRoom, "Private Room");

        GameTypeEnum gameType = (GameTypeEnum)Toolbar((int)room.gameType, new[] { "StreetRace", "Pursuit", "Deathmatch", "TDM" }, hor: 2, title: "Game Type");

        if (gameType != room.gameType)
        {
            room.gameType  = gameType;
            room.matchTime = 3 * 60;
        }
        room.maxPlayers2 = (int)HorizontalSlider("Max Players", room.maxPlayers2, 1, 30, startButton);
        gui.EndVertical();
        gui.BeginVertical(skin.box);
        gui.Label(mapStats.texture);
        Label(Tr("Select Map"));
        foreach (var a in bs.settings.maps)
        {
            if ((a.hidden == 0 || isDebug) && GlowButton(a.mapName, a == room.sets.mapStats))
            {
                room.sets.mapStats = a;
            }
        }
        gui.EndVertical();
        gui.EndHorizontal();

        if (startButton)
        {
            _Loader.StartCoroutine(_Loader.LoadLevel(true));
        }
    }
コード例 #13
0
 /// <summary>
 /// game type -> level select
 /// </summary>
 private void OnGameType_SelectSinglePlayer(Button button, MouseButtonEventArgs eventArgs)
 {
     GameType = GameTypeEnum.SinglePlayer;
     SwitchGui(mmm.GameTypeGui, mmm.LevelSelectGui);
 }
コード例 #14
0
 public static int NumberOfWinsBy(this IEnumerable <HistoryModel> historyModels, GameTypeEnum gameType)
 {
     return(historyModels.Count((historyModel) => gameType == historyModel.GameType));
 }
コード例 #15
0
 public static GameInformation GetGameById(GameTypeEnum type)
 {
     return(Games.FirstOrDefault(x => x.Type == type));
 }
コード例 #16
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="gameType"></param>
 public GameTypeAttribute(GameTypeEnum gameType)
 {
     GameType = gameType;
 }
コード例 #17
0
        /// <summary>
        /// creates a new instance and overall a brand new roller derby game.
        /// </summary>
        public void createNewGame(GameTypeEnum gameType)
        {
            try
            {
                //we need to save the settings from the initial window that the user selected.
                bool saveGameOnline = GameViewModel.Instance.SaveGameOnline;
                bool publishGame = GameViewModel.Instance.PublishGameOnline;
                bool beingTested = GameViewModel.Instance.IsBeingTested;

                instance = new GameViewModel();
#if DEBUG
                instance.ScoreboardMode = ScoreboardModeEnum.Debug;
#else
                instance.ScoreboardMode = ScoreboardModeEnum.Live;
#endif
                instance.SaveGameOnline = saveGameOnline;
                instance.PublishGameOnline = publishGame;
                instance.IsBeingTested = beingTested;

                instance.GameId = Guid.NewGuid();
                instance.IdForOnlineManagementUse = Guid.NewGuid();

                instance.Policy = PolicyViewModel.Instance;
                instance.Team1.TimeOutsLeft = PolicyViewModel.Instance.TimeOutsPerPeriod;
                instance.Team2.TimeOutsLeft = PolicyViewModel.Instance.TimeOutsPerPeriod;
                //must start with a negative one for pre game intermissions...
                //should prob do this a better way, but havent figured it out yet.
                GameViewModel.Instance.CurrentPeriod = 0;

                //TODO: Team names should be different?
                instance.Team1.TeamName = "Home";
                instance.CurrentTeam1Score = 0;
                instance.CurrentTeam1JamScore = 0;
                instance.ScoresTeam1 = new List<ScoreViewModel>();
                instance.Team1.TeamId = Guid.NewGuid();
                instance.Team2.TeamName = "Away";

                instance.Team1.Logo = new TeamLogo();
                instance.Team2.Logo = new TeamLogo();
                instance.CurrentTeam2Score = 0;
                instance.CurrentTeam2JamScore = 0;
                instance.ScoresTeam2 = new List<ScoreViewModel>();
                instance.Team2.TeamId = Guid.NewGuid();
                instance.GameDate = DateTime.UtcNow;
                instance.TimeOuts = new List<TimeOutViewModel>();
                instance.GameName = "Bout";
                instance.CurrentIntermission = GameViewModelIntermissionTypeEnum.PreGameIntermission;
                instance.NameOfIntermission = PolicyViewModel.Instance.IntermissionOtherText;
                createNewPeriod();
                createLineUpClock();
                instance.Jams.Clear();
                instance.CurrentJam = null;
                createNewJam();
                createNewIntermission();
                instance.Advertisements = new List<AdvertisementViewModel>();
                instance.SlideShowSlides = new List<SlideShowViewModel>();
                AdvertisementViewModel.getAdvertsFromDirectory();
                setupAdvertisements();
                setCurrentAdvertisement();
                _team1.clearTeamPositions();
                _team2.clearTeamPositions();
                setupTimerForOnlineGame();
                setupTimerForSlideShow();
                instance.EditModeItems = new List<EditModeModel>();
                instance.AssistsForTeam1 = new List<AssistViewModel>();
                instance.BlocksForTeam1 = new List<BlockViewModel>();
                instance.PenaltiesForTeam1 = new List<PenaltyViewModel>();
                instance.AssistsForTeam2 = new List<AssistViewModel>();
                instance.BlocksForTeam2 = new List<BlockViewModel>();
                instance.PenaltiesForTeam2 = new List<PenaltyViewModel>();
                instance.OfficialReviews = new List<OfficialReviewViewModel>();
                instance.UsingServerScoring = false;
                instance.Officials = new Officials.Officials();
                instance.ScoreboardSettings = new ScoreboardSettings();
                liveGameTimer_Elapsed(this, null);
                this.NewGame(this, null);
            }
            catch (Exception e)
            {
                ErrorViewModel.Save(e, this.GetType(), ErrorGroupEnum.UI);
            }
        }
コード例 #18
0
 public static void SetGameType(GameTypeEnum value)
 {
     PlayerPrefs.SetString(GAME_TYPE_KEY, value.ToString());
 }
コード例 #19
0
    private RoomInfo GetRoom(GameTypeEnum GameType)
    {
        var rooms = _Loader.GetRoomList();
        var orderByDescending = rooms.Where(a => !a.privateRoom && ValidateRoom(a) && a.playerCount < 8 && (a.version == bs.settings.mpVersion)).OrderByDescending(a => a.playerCount);
        if (android && !Application.isEditor)
            orderByDescending = orderByDescending.OrderBy(a => a.maxPlayers);
        RoomInfo firstOrDefault = orderByDescending.FirstOrDefault(a => a.gameType == (GameType));

        return firstOrDefault;
    }
コード例 #20
0
        public async Task <GameType> GetGameType(GameTypeEnum typeIn)
        {
            var sql = @"select Id, Name, RollsPerGame, MaxPlaysPerDay From GameTypes where Id = @typeId";

            return(await _conn.QueryFirstOrDefaultAsync <GameType>(sql, new { typeId = (int)typeIn }));
        }
コード例 #21
0
 /// <summary>
 /// level select -> previous
 /// </summary>
 private void OnLevelSelect_SelectBack(Button button, MouseButtonEventArgs eventArgs)
 {
     switch (GameType)
     {
         case GameTypeEnum.SinglePlayer:
             GameType = GameTypeEnum.None;
             SwitchGui(mmm.LevelSelectGui, mmm.GameTypeGui);
             break;
         case GameTypeEnum.NetworkedHost:
             mmm.NetworkHostPasswordTextBox.Text = "";
             mmm.NetworkHostPortTextBox.Text = "";
             LKernel.GetG<NetworkManager>().StopThread();
             SwitchGui(mmm.LevelSelectGui, mmm.NetworkHostGui);
             break;
         default:
             throw new InvalidOperationException("OnLevelSelect_SelectBack was invoked from an invalid GUI state - how did we get here?");
     }
 }
コード例 #22
0
        private async void SaveButton_Click(object sender, RoutedEventArgs e)
        {
            await this.RunAsyncOperation(async() =>
            {
                if (string.IsNullOrEmpty(this.GameNameTextBox.Text))
                {
                    await MessageBoxHelper.ShowMessageDialog("Name is missing");
                    return;
                }

                if (string.IsNullOrEmpty(this.GameChatCommandTextBox.Text))
                {
                    await MessageBoxHelper.ShowMessageDialog("Commands is missing");
                    return;
                }

                if (this.GameChatCommandTextBox.Text.Any(c => !Char.IsLetterOrDigit(c) && !Char.IsWhiteSpace(c)))
                {
                    await MessageBoxHelper.ShowMessageDialog("Commands can only contain letters and numbers");
                    return;
                }

                foreach (PermissionsCommandBase command in ChannelSession.AllChatCommands)
                {
                    if (this.command != command && this.GameNameTextBox.Text.Equals(command.Name))
                    {
                        await MessageBoxHelper.ShowMessageDialog("There already exists a chat command with the same name");
                        return;
                    }
                }

                IEnumerable <string> commandStrings = this.GetCommandStrings();
                if (commandStrings.GroupBy(c => c).Where(g => g.Count() > 1).Count() > 0)
                {
                    await MessageBoxHelper.ShowMessageDialog("Each command string must be unique");
                    return;
                }

                foreach (PermissionsCommandBase command in ChannelSession.AllChatCommands)
                {
                    if (command.IsEnabled && this.GetExistingCommand() != command)
                    {
                        if (commandStrings.Any(c => command.Commands.Contains(c)))
                        {
                            await MessageBoxHelper.ShowMessageDialog("There already exists a chat command that uses one of the command strings you have specified");
                            return;
                        }
                    }
                }

                int cooldown = 0;
                if (!int.TryParse(this.GameCooldownTextBox.Text, out cooldown) || cooldown < 0)
                {
                    await MessageBoxHelper.ShowMessageDialog("Cooldown must be 0 or greater");
                    return;
                }

                if (this.GameLowestRoleAllowedComboBox.SelectedIndex < 0)
                {
                    await MessageBoxHelper.ShowMessageDialog("A permission level must be selected");
                    return;
                }

                if (this.GameTypeComboBox.SelectedIndex < 0)
                {
                    await MessageBoxHelper.ShowMessageDialog("A game type must be selected");
                    return;
                }
                GameTypeEnum gameType = EnumHelper.GetEnumValueFromString <GameTypeEnum>((string)this.GameTypeComboBox.SelectedItem);

                if (this.CurrencyTypeComboBox.SelectedIndex < 0 || this.CurrencyRequirementTypeComboBox.SelectedIndex < 0)
                {
                    await MessageBoxHelper.ShowMessageDialog("A currency type and requirement must be selected");
                    return;
                }

                int minimum = 0;
                int maximum = 0;

                CurrencyRequirementTypeEnum currencyRequirementType = EnumHelper.GetEnumValueFromString <CurrencyRequirementTypeEnum>((string)this.CurrencyRequirementTypeComboBox.SelectedItem);
                if (currencyRequirementType != CurrencyRequirementTypeEnum.NoCurrencyCost && (!int.TryParse(this.CurrencyMinimumCostTextBox.Text, out minimum) || minimum < 0))
                {
                    await MessageBoxHelper.ShowMessageDialog("The currency minimum must be 0 or greater");
                    return;
                }

                if (currencyRequirementType == CurrencyRequirementTypeEnum.MinimumAndMaximum && (!int.TryParse(this.CurrencyMaximumCostTextBox.Text, out maximum) || maximum <= minimum))
                {
                    await MessageBoxHelper.ShowMessageDialog("The currency maximum must be greater than the minimum");
                    return;
                }

                int gameLength      = 0;
                int minParticipants = 0;
                if (this.MultiplayerGameDetailsGrid.Visibility == Visibility.Visible)
                {
                    if (!int.TryParse(this.GameLengthTextBox.Text, out gameLength) || gameLength < 0)
                    {
                        await MessageBoxHelper.ShowMessageDialog("Game length must be 0 or greater");
                        return;
                    }

                    if (!int.TryParse(this.GameMinimumParticipantsTextBox.Text, out minParticipants) || minParticipants < 1)
                    {
                        await MessageBoxHelper.ShowMessageDialog("Minimum participants must be 1 or greater");
                        return;
                    }
                }

                List <GameOutcome> outcomes           = new List <GameOutcome>();
                List <GameOutcomeGroup> outcomeGroups = new List <GameOutcomeGroup>();
                if (gameType == GameTypeEnum.SinglePlayer || gameType == GameTypeEnum.IndividualProbabilty)
                {
                    foreach (GameOutcomeCommandControl commandControl in this.outcomeCommandControls)
                    {
                        GameOutcome outcome = await commandControl.GetOutcome();
                        if (outcome == null)
                        {
                            return;
                        }
                        outcomes.Add(outcome);
                    }

                    if (outcomes.Select(o => o.Name).GroupBy(n => n).Where(g => g.Count() > 1).Count() > 0)
                    {
                        await MessageBoxHelper.ShowMessageDialog("Each outcome must have a unique name");
                        return;
                    }

                    foreach (GameOutcomeGroupControl groupControl in this.outcomeGroupControls)
                    {
                        GameOutcomeGroup group = await groupControl.GetOutcomeGroup();
                        if (group == null)
                        {
                            return;
                        }
                        outcomeGroups.Add(group);
                        for (int i = 0; i < outcomes.Count; i++)
                        {
                            group.Probabilities[i].OutcomeName = outcomes[i].Name;
                        }
                    }
                }

                UserRole permissionsRole = EnumHelper.GetEnumValueFromString <UserRole>((string)this.GameLowestRoleAllowedComboBox.SelectedItem);

                if (this.command != null)
                {
                    ChannelSession.Settings.GameCommands.Remove(this.command);
                }

                UserCurrencyRequirementViewModel currencyRequirement = new UserCurrencyRequirementViewModel((UserCurrencyViewModel)this.CurrencyTypeComboBox.SelectedItem, minimum, maximum);
                if (gameType == GameTypeEnum.SinglePlayer)
                {
                    this.command = new SinglePlayerGameCommand(this.GameNameTextBox.Text, this.GetCommandStrings(), permissionsRole, cooldown, currencyRequirement, currencyRequirementType, outcomes,
                                                               outcomeGroups, this.LoseLeftoverProbabilityCommandControl.GetCommand());
                }
                else if (gameType == GameTypeEnum.IndividualProbabilty)
                {
                    IndividualProbabilityGameCommand ipCommand = new IndividualProbabilityGameCommand(this.GameNameTextBox.Text, this.GetCommandStrings(), permissionsRole, cooldown,
                                                                                                      currencyRequirement, currencyRequirementType, outcomes, outcomeGroups, this.LoseLeftoverProbabilityCommandControl.GetCommand(), gameLength, minParticipants);
                    ipCommand.GameStartedCommand    = this.GameStartedCommandControl.GetCommand();
                    ipCommand.GameEndedCommand      = this.GameEndedCommandControl.GetCommand();
                    ipCommand.UserJoinedCommand     = this.UserJoinedCommandControl.GetCommand();
                    ipCommand.NotEnoughUsersCommand = this.NotEnoughUsersCommandControl.GetCommand();
                    this.command = ipCommand;
                }
                else if (gameType == GameTypeEnum.OnlyOneWinner)
                {
                    OnlyOneWinnerGameCommand oowCommand = new OnlyOneWinnerGameCommand(this.GameNameTextBox.Text, this.GetCommandStrings(), permissionsRole, cooldown, currencyRequirement,
                                                                                       gameLength, minParticipants);
                    oowCommand.GameStartedCommand    = this.GameStartedCommandControl.GetCommand();
                    oowCommand.GameEndedCommand      = this.GameEndedCommandControl.GetCommand();
                    oowCommand.UserJoinedCommand     = this.UserJoinedCommandControl.GetCommand();
                    oowCommand.NotEnoughUsersCommand = this.NotEnoughUsersCommandControl.GetCommand();
                    this.command = oowCommand;
                }
                else if (gameType == GameTypeEnum.UserCharity)
                {
                    UserCharityGameCommand ucCommand = new UserCharityGameCommand(this.GameNameTextBox.Text, this.GetCommandStrings(), permissionsRole, cooldown, currencyRequirement,
                                                                                  currencyRequirementType, this.GiveToRandomUserCharityToggleButton.IsChecked.GetValueOrDefault());
                    ucCommand.UserParticipatedCommand = this.UserParticipatedCommandControl.GetCommand();
                    this.command = ucCommand;
                }

                ChannelSession.Settings.GameCommands.Add(this.command);

                await ChannelSession.SaveSettings();

                this.Close();
            });
        }
コード例 #23
0
        /// <summary>
        /// makes the proper game policy changes to the game
        /// </summary>
        /// <param name="gameType"></param>
        public void changeGameSelectionType(GameTypeEnum gameType)
        {
            GameSelectionType = gameType.ToString();
            if (gameType == GameTypeEnum.MADE)
            {
                NumberOfPeriods = 4;
                PeriodClock = (long)TimeSpan.FromMinutes(15).TotalMilliseconds;
                JamClockTimePerJam = (long)TimeSpan.FromSeconds(90).TotalMilliseconds;
                LineUpClockPerJam = (long)TimeSpan.FromSeconds(30).TotalMilliseconds;
                TimeOutsPerPeriod = 3;
            }
            else if (gameType == GameTypeEnum.MADE_COED)
            {
                NumberOfPeriods = 8;
                PeriodClock = (long)TimeSpan.FromMinutes(10).TotalMilliseconds;
                JamClockTimePerJam = (long)TimeSpan.FromSeconds(90).TotalMilliseconds;
                LineUpClockPerJam = (long)TimeSpan.FromSeconds(30).TotalMilliseconds;
                TimeOutsPerPeriod = 3;

            }
            else if (gameType == GameTypeEnum.WFTDA)
            {
                NumberOfPeriods = 2;
                PeriodClock = (long)TimeSpan.FromMinutes(30).TotalMilliseconds;
                JamClockTimePerJam = (long)TimeSpan.FromMinutes(2).TotalMilliseconds;
                LineUpClockPerJam = (long)TimeSpan.FromSeconds(30).TotalMilliseconds;
                TimeOutsPerPeriod = 2;
            }
            else if (gameType == GameTypeEnum.RENEGADE)
            {//TODO: find renenegade rule set
            }
            else if (gameType == GameTypeEnum.OSDA)
            {
                NumberOfPeriods = 4;
                PeriodClock = (long)TimeSpan.FromMinutes(15).TotalMilliseconds;
                JamClockTimePerJam = (long)TimeSpan.FromMinutes(90).TotalMilliseconds;
                LineUpClockPerJam = (long)TimeSpan.FromSeconds(30).TotalMilliseconds;
                TimeOutsPerPeriod = 1;
            }
            else if (gameType == GameTypeEnum.OSDA_COED)
            {
                NumberOfPeriods = 8;
                PeriodClock = (long)TimeSpan.FromMinutes(10).TotalMilliseconds;
                JamClockTimePerJam = (long)TimeSpan.FromSeconds(90).TotalMilliseconds;
                LineUpClockPerJam = (long)TimeSpan.FromSeconds(30).TotalMilliseconds;
                TimeOutsPerPeriod = 1;
            }
        }
コード例 #24
0
 /// <summary>
 /// game type -> network host
 /// </summary>
 private void OnGameType_SelectNetworkedHost(Button button, MouseButtonEventArgs eventArgs)
 {
     GameType = GameTypeEnum.NetworkedHost;
     mmm.NetworkHostPasswordTextBox.Text = "";
     mmm.NetworkHostPortTextBox.Text = "";
     SwitchGui(mmm.GameTypeGui, mmm.NetworkHostGui);
 }
コード例 #25
0
        /// <summary>
        /// creates a new instance and overall a brand new roller derby game.
        /// </summary>
        public void createNewGame(GameTypeEnum gameType)
        {
            instance = new GameViewModel();
            instance.GameId = Guid.NewGuid();

            //instance.Periods = Config.WFTDA_DEFAULT_PERIODS;
            instance.Team1.TimeOutsLeft = PolicyViewModel.Instance.TimeOutsPerPeriod;
            instance.Team2.TimeOutsLeft = PolicyViewModel.Instance.TimeOutsPerPeriod;
            GameViewModel.Instance.CurrentPeriod = 0;

            //TODO: Team names should be different?
            instance.Team1.TeamName = "Home";
            instance.CurrentTeam1Score = 0;
            instance.ScoresTeam1 = new List<ScoreViewModel>();
            instance.Team1.TeamId = Guid.NewGuid();
            instance.Team2.TeamName = "Away";
            instance.CurrentTeam2Score = 0;
            instance.ScoresTeam2 = new List<ScoreViewModel>();
            instance.Team2.TeamId = Guid.NewGuid();
            instance.GameDate = DateTime.UtcNow;
            instance.TimeOuts = new List<TimeOutViewModel>();
            createNewPeriod();
            createNewJam();
            createLineUpClock();
            instance.Advertisements = new List<AdvertisementViewModel>();
            AdvertisementViewModel.getAdvertsFromDirectory();
            setupAdvertisements();
            setCurrentAdvertisement();
            this.NewGame(this, null);




        }
コード例 #26
0
        private async void GameTypeComboBox_SelectionChanged(object sender, System.Windows.Controls.SelectionChangedEventArgs e)
        {
            await this.RunAsyncOperation(async() =>
            {
                if (this.GameTypeComboBox.SelectedIndex >= 0)
                {
                    this.CurrencyGrid.IsEnabled = true;

                    this.MultiplayerGameDetailsGrid.Visibility = Visibility.Collapsed;
                    this.OutcomesDetailsGrid.Visibility        = Visibility.Collapsed;
                    this.UserCharityGameGrid.Visibility        = Visibility.Collapsed;

                    GameTypeEnum gameType = EnumHelper.GetEnumValueFromString <GameTypeEnum>((string)this.GameTypeComboBox.SelectedItem);

                    if (gameType == GameTypeEnum.OnlyOneWinner)
                    {
                        this.CurrencyRequirementTypeComboBox.SelectedItem = EnumHelper.GetEnumName(CurrencyRequirementTypeEnum.RequiredAmount);
                        this.CurrencyRequirementTypeComboBox.IsEnabled    = false;
                    }
                    else
                    {
                        this.CurrencyRequirementTypeComboBox.SelectedIndex = -1;
                        this.CurrencyRequirementTypeComboBox.IsEnabled     = true;
                    }

                    if (gameType == GameTypeEnum.IndividualProbabilty || gameType == GameTypeEnum.OnlyOneWinner)
                    {
                        this.MultiplayerGameDetailsGrid.Visibility = Visibility.Visible;
                    }

                    if (gameType == GameTypeEnum.SinglePlayer || gameType == GameTypeEnum.IndividualProbabilty)
                    {
                        this.OutcomesDetailsGrid.Visibility = Visibility.Visible;

                        this.outcomeCommandControls.Clear();

                        GameOutcomeCommandControl outcomeControl = new GameOutcomeCommandControl(new GameOutcome("Win"));
                        await outcomeControl.Initialize(this);
                        this.outcomeCommandControls.Add(outcomeControl);

                        this.outcomeGroupControls.Clear();

                        GameOutcomeGroup userGroup = new GameOutcomeGroup(UserRole.User);
                        userGroup.Probabilities.Add(new GameOutcomeProbability(50, 25));
                        this.outcomeGroupControls.Add(new GameOutcomeGroupControl(userGroup));

                        GameOutcomeGroup subscriberGroup = new GameOutcomeGroup(UserRole.Subscriber);
                        subscriberGroup.Probabilities.Add(new GameOutcomeProbability(50, 25));
                        this.outcomeGroupControls.Add(new GameOutcomeGroupControl(subscriberGroup));

                        GameOutcomeGroup modGroup = new GameOutcomeGroup(UserRole.Mod);
                        modGroup.Probabilities.Add(new GameOutcomeProbability(50, 25));
                        this.outcomeGroupControls.Add(new GameOutcomeGroupControl(modGroup));
                    }

                    if (gameType == GameTypeEnum.UserCharity)
                    {
                        this.UserCharityGameGrid.Visibility = Visibility.Visible;
                    }
                }
            });
        }
コード例 #27
0
        /// <summary>
        /// makes the proper game policy changes to the game
        /// </summary>
        /// <param name="gameType"></param>
        public void changeGameSelectionType(GameTypeEnum gameType)
        {
            try
            {
                GameSelectionType = gameType;
                if (gameType == GameTypeEnum.MADE)
                {
                    instance.NumberOfPeriods = 4;
                    instance.PeriodClock = (long)TimeSpan.FromMinutes(15).TotalMilliseconds;
                    instance.JamClockTimePerJam = (long)TimeSpan.FromSeconds(90).TotalMilliseconds;
                    instance.LineUpClockPerJam = (long)TimeSpan.FromSeconds(30).TotalMilliseconds;
                    instance.TimeOutsPerPeriod = 1;
                }
                else if (gameType == GameTypeEnum.TEXAS_DERBY)
                {
                    instance.NumberOfPeriods = 4;
                    instance.PeriodClock = (long)TimeSpan.FromMinutes(8).TotalMilliseconds;
                    instance.JamClockTimePerJam = (long)TimeSpan.FromSeconds(60).TotalMilliseconds;
                    instance.LineUpClockPerJam = (long)TimeSpan.FromSeconds(30).TotalMilliseconds;
                    instance.TimeOutsPerPeriod = 1;
                    instance.TimeOutClock = (long)TimeSpan.FromSeconds(120).TotalMilliseconds;
                }
                else if (gameType == GameTypeEnum.MADE_COED)
                {
                    instance.NumberOfPeriods = 8;
                    instance.PeriodClock = (long)TimeSpan.FromMinutes(15).TotalMilliseconds;
                    instance.JamClockTimePerJam = (long)TimeSpan.FromSeconds(90).TotalMilliseconds;
                    instance.LineUpClockPerJam = (long)TimeSpan.FromSeconds(30).TotalMilliseconds;
                    instance.TimeOutsPerPeriod = 1;
                }
                else if (gameType == GameTypeEnum.RDCL)
                {
                    instance.NumberOfPeriods = 4;
                    instance.PeriodClock = (long)TimeSpan.FromMinutes(15).TotalMilliseconds;
                    instance.JamClockTimePerJam = (long)TimeSpan.FromSeconds(60).TotalMilliseconds;
                    instance.LineUpClockPerJam = (long)TimeSpan.FromSeconds(30).TotalMilliseconds;
                    instance.TimeOutsPerPeriod = 3;

                }
                else if (gameType == GameTypeEnum.WFTDA_2010)
                {
                    instance.NumberOfPeriods = 2;
                    instance.PeriodClock = (long)TimeSpan.FromMinutes(30).TotalMilliseconds;
                    instance.JamClockTimePerJam = (long)TimeSpan.FromMinutes(2).TotalMilliseconds;
                    instance.LineUpClockPerJam = (long)TimeSpan.FromSeconds(30).TotalMilliseconds;
                    instance.TimeOutsPerPeriod = 2;
                    instance.StopPeriodClockWhenLineUpClockHitsZero = false;
                }
                else if (gameType == GameTypeEnum.WFTDA)
                {
                    instance.NumberOfPeriods = 2;
                    instance.PeriodClock = (long)TimeSpan.FromMinutes(30).TotalMilliseconds;
                    instance.JamClockTimePerJam = (long)TimeSpan.FromMinutes(2).TotalMilliseconds;
                    instance.LineUpClockPerJam = (long)TimeSpan.FromSeconds(30).TotalMilliseconds;
                    instance.TimeOutsPerPeriod = 3;
                    instance.StopPeriodClockWhenLineUpClockHitsZero = false;
                }
                else if (gameType == GameTypeEnum.USARS)
                {
                    instance.NumberOfPeriods = 2;
                    instance.PeriodClock = (long)TimeSpan.FromMinutes(30).TotalMilliseconds;
                    instance.JamClockTimePerJam = (long)TimeSpan.FromMinutes(2).TotalMilliseconds;
                    instance.LineUpClockPerJam = (long)TimeSpan.FromSeconds(30).TotalMilliseconds;
                    instance.TimeOutsPerPeriod = 3;
                    instance.TimeOutClock = (long)TimeSpan.FromSeconds(90).TotalMilliseconds;
                }
                else if (gameType == GameTypeEnum.RENEGADE)
                {//TODO: find renenegade rule set
                }
                else if (gameType == GameTypeEnum.OSDA)
                {
                    instance.NumberOfPeriods = 4;
                    instance.PeriodClock = (long)TimeSpan.FromMinutes(15).TotalMilliseconds;
                    instance.JamClockTimePerJam = (long)TimeSpan.FromMinutes(90).TotalMilliseconds;
                    instance.LineUpClockPerJam = (long)TimeSpan.FromSeconds(30).TotalMilliseconds;
                    instance.TimeOutsPerPeriod = 1;
                }
                else if (gameType == GameTypeEnum.OSDA_COED)
                {
                    instance.NumberOfPeriods = 8;
                    instance.PeriodClock = (long)TimeSpan.FromMinutes(10).TotalMilliseconds;
                    instance.JamClockTimePerJam = (long)TimeSpan.FromSeconds(90).TotalMilliseconds;
                    instance.LineUpClockPerJam = (long)TimeSpan.FromSeconds(30).TotalMilliseconds;
                    instance.TimeOutsPerPeriod = 1;
                }
                else if (gameType == GameTypeEnum.CUSTOM)
                {
                    //because its custom game, we let the user decide all the presets.
                }
            }
            catch (Exception exception)
            {
                ErrorViewModel.Save(exception, this.GetType(), ErrorGroupEnum.UI);
            }
        }
コード例 #28
0
 ///////////////////////////////////////////////////////////////////////////////////////////////////////
 /// <summary>
 /// network host -> game type
 /// </summary>
 private void OnHostInfo_SelectBack(Button button, MouseButtonEventArgs eventArgs)
 {
     GameType = GameTypeEnum.None;
     SwitchGui(mmm.NetworkHostGui, mmm.GameTypeGui);
 }
コード例 #29
0
 public static void SetGameType(GameTypeEnum arg_gameType)
 {
     gameType = arg_gameType;
 }
コード例 #30
0
 private void OnLevelLoad(LevelChangedEventArgs eventArgs)
 {
     // don't need to unhide/hide any GUIs, since that's all done in the MainMenuManager
     if (eventArgs.NewLevel.Type == LevelType.Menu)
         GameType = GameTypeEnum.None;
 }