Beispiel #1
0
 /// <summary>
 /// When created the initial status and score of the player are determined
 /// </summary>
 /// <param name="shoeService">depending on the implementation (strategy pattern) of the shoe the hand may differ</param>
 /// <param name="scoreCalculator"></param>
 /// <param name="name"></param>
 protected Player(IShoeService shoeService, IScoreCalculator scoreCalculator, string name = "")
 {
     _scoreCalculator = scoreCalculator;
     ShoeService = shoeService;
     Name = name;
     Reset();
 }
        public void ShouldReturnACalculatorBasedOnEnum(ScoreCategory a_scoreCategory, Type a_type)
        {
            sut = new ScoreCalculatorFactory();
            IScoreCalculator actual = sut.GetScoreCalculator(a_scoreCategory);

            Assert.True(actual.GetType() == a_type);
        }
Beispiel #3
0
 public Runner(ParserBase <TInput> parser, ISolver <TInput, TOutput> solver, PrinterBase <TOutput> printer, ScoreCalculatorBase <TInput, TOutput> calculator = null)
 {
     m_Parser     = parser;
     m_Solver     = solver;
     m_Printer    = printer;
     m_Calculator = calculator;
 }
Beispiel #4
0
        private void Start()
        {
            _gameState.ResetData();
            _grid = new TetrisGrid(_gridHeight, _gridWidth);
            _grid.GridOverflowed += GridOnGridOverflowed;

            _soundManager = GetComponent <SoundManager>();
            _spawner      = GetComponent <RandomPrefabsSpawner>();
            _inputManager = new InputManagersWrapper(new List <IInputManager>()
            {
                GetComponent <InputManager>(),
                GetComponent <TouchInputManager>()
            });

            _scoreCalculator            = new ScoreCalculator(_gameState, _scoreData);
            _levelManager               = new LevelManager(_gameState, 10, _maxLevel);
            _preview                    = new GameObject("Preview", new Type[] { typeof(SpriteRenderer) });
            _preview.transform.position = _previewPosition;

            _currentTetromino = CreateTetromino();
            InitializeCurrentTetromino();

            _nextTetromino = CreateTetromino();
            SetUpPreview();
        }
Beispiel #5
0
 public ScoreboardManager(GameDataManager gameData, IScoreCalculator scoreCalculator, ISerializer serializer)
 {
     _gameData        = gameData;
     _serializer      = serializer;
     _scoreCalculator = scoreCalculator;
     Load();
 }
Beispiel #6
0
 /// <summary>
 /// Initializes a new instance of the <see cref="InGameState"/> class.
 /// </summary>
 /// <param name="gameLogic">Object that holds the game logic.</param>
 /// <param name="gameStatistics">Object that holds the game statistics.</param>
 /// <param name="fileIo">Object that holds information where the data should be saved.</param>
 public InGameState(IGameLogic gameLogic, IScoreCalculator gameStatistics, IFileIo fileIo)
 {
     this.gameLogic       = gameLogic;
     this.scoreCalculator = gameStatistics;
     this.fileIo          = fileIo;
     this.message         = "Welcome, please make your guess:";
 }
 public QuizService(UniquizbitDbContext dbContext,
                    IOptions <GradesSettings> optionsAccessor,
                    IScoreCalculator scoreCalculator)
 {
     _scoreCalculator = scoreCalculator;
     _dbContext       = dbContext;
     _gradesSettings  = optionsAccessor.Value;
 }
 public ScoreQuery(ISignaler signaler, IScoreCalculator scoreCalculator)
 {
     _signaler = signaler;
     _scoreCalculator = scoreCalculator;
     _gamesPlayed = 0;
     _playerCount = 0;
     _minMaxCache = new MinMaxCache<double>(PlayarStatisistics.InitialScore, PlayarStatisistics.InitialScore);
 }
Beispiel #9
0
 public ScoreQuery(ISignaler signaler, IScoreCalculator scoreCalculator)
 {
     _signaler        = signaler;
     _scoreCalculator = scoreCalculator;
     _gamesPlayed     = 0;
     _playerCount     = 0;
     _minMaxCache     = new MinMaxCache <double>(PlayarStatisistics.InitialScore, PlayarStatisistics.InitialScore);
 }
        public GameService(ILetterPairGenerator letterPairGenerator, ITimer timer, IScoreCalculator scoreCalculator)
        {
            _letterPairGenerator = letterPairGenerator ?? throw new ArgumentNullException(nameof(letterPairGenerator));
            _timer           = timer ?? throw new ArgumentNullException(nameof(timer));
            _scoreCalculator = scoreCalculator ?? throw new ArgumentException(nameof(scoreCalculator));

            SubscribeToCustomEvents();
        }
Beispiel #11
0
 public BowlingGame()
 {
     _calculator = new ScoreCalculator();
     for (int i = 0; i < FramesPerGame - 1; i++)
     {
         _frames.Add(new Frame());
     }
     _frames.Add(new LastFrame());
 }
Beispiel #12
0
 public QuestionVM(
     IDateTime dateTime,
     IDictionaryEntryPicker dictionaryEntryPicker,
     IScoreCalculator scoreCalculator)
 {
     _dateTime = dateTime;
     _dictionaryEntryPicker = dictionaryEntryPicker;
     _scoreCalculator       = scoreCalculator;
 }
Beispiel #13
0
 public Lobby(IHubContext <LobbyHub> lobbyHub, IWordsProviderService wordsProviderService,
              IScoreCalculator scoreCalculator, IWordDistanceCalculator wordDistanceCalculator)
 {
     _lobbyHub             = lobbyHub ?? throw new ArgumentNullException(nameof(lobbyHub));
     _wordsProviderService =
         wordsProviderService ?? throw new ArgumentNullException(nameof(wordsProviderService));
     _scoreCalculator        = scoreCalculator ?? throw new ArgumentNullException(nameof(scoreCalculator));
     _wordDistanceCalculator =
         wordDistanceCalculator ?? throw new ArgumentNullException(nameof(wordDistanceCalculator));
 }
Beispiel #14
0
    public PlayerYearInfo(string paramPlayer, List <string> paramEventNames, IScoreCalculator paramCalculator)
    {
        Player      = paramPlayer;
        _calculator = paramCalculator;

        foreach (string name in paramEventNames)
        {
            _events.Add(new PlayerEventInfo(name));
        }
    }
Beispiel #15
0
 public ScoreManager(IGridWrapper grid, IBubbleSpawner spawner, IScoreCalculator calculator,
                     IBubbleCollector collector, IBubbleExploder exploder, IGridManager gridManager, ScoreRange scoreRange)
 {
     this.grid        = grid;
     this.spawner     = spawner;
     this.calculator  = calculator;
     this.collector   = collector;
     this.exploder    = exploder;
     this.gridManager = gridManager;
     this.scoreRange  = scoreRange;
 }
Beispiel #16
0
 public ScoreboardModel(IPredictionData predictionData, IUserData userData, ApplicationDbContext context,
                        IAuthorizationService authorizationService, IScoreCalculator scoreCalculator,
                        IGameConverter gameConverter,
                        UserManager <ApplicationUser> userManager)
     : base(context, authorizationService, userManager)
 {
     _predictionData  = predictionData;
     _userData        = userData;
     _scoreCalculator = scoreCalculator;
     _gameConverter   = gameConverter;
 }
Beispiel #17
0
        public Runner(string outputDirectoryName, ParserBase <TInput> parser, SolverBase <TInput, TOutput> solver, PrinterBase <TOutput> printer, ScoreCalculatorBase <TInput, TOutput> calculator = null)
        {
            m_Parser     = parser;
            m_Solver     = solver;
            m_Printer    = printer;
            m_Calculator = calculator;
            var solutionPath = Path.GetDirectoryName(Path.GetDirectoryName(Path.GetDirectoryName(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location))));

            m_OutputDirectory = Path.Combine(solutionPath, "Output", outputDirectoryName);

            Directory.CreateDirectory(m_OutputDirectory);
        }
Beispiel #18
0
 public ChampionshipManager(TeamCreator teamCreator,
                            IMatchResultGatherer matchResultGatherer,
                            IScoreCalculator scoreCalculator,
                            IRatingCalculator ratingCalculator,
                            IRepository repository)
 {
     TeamCreator         = teamCreator;
     MatchResultGatherer = matchResultGatherer;
     ScoreCalculator     = scoreCalculator;
     RatingCalculator    = ratingCalculator;
     Repository          = repository;
 }
Beispiel #19
0
        public void AddScore(int score, IScoreCalculator calculator)
        {
            var type = calculator.GetType();

            if (_scores.ContainsKey(type))
            {
                _scores[type] = score;
            }
            else
            {
                _scores.Add(type, score);
            }
        }
Beispiel #20
0
        public CommentRepository(
            IPhotoRepository photoRepository,
            IDynamoDbCore dynamoDbCore,
            ISystem system,
            IScoreCalculator scoreCalculator,
            ILogWriterFactory logWriterFactory)
        {
            if (logWriterFactory is null)
            {
                throw new System.ArgumentNullException(nameof(logWriterFactory));
            }

            logWriter            = logWriterFactory.CreateLogger <CommentRepository>();
            this.photoRepository = photoRepository ?? throw new System.ArgumentNullException(nameof(photoRepository));
            this.dynamoDbCore    = dynamoDbCore ?? throw new ArgumentNullException(nameof(dynamoDbCore));
            this.system          = system ?? throw new ArgumentNullException(nameof(system));
            this.scoreCalculator = scoreCalculator ?? throw new ArgumentNullException(nameof(scoreCalculator));
            tableName            = system.Environment.GetVariable(Constants.EnvironmentVariables.DynamoDbTableName);
        }
Beispiel #21
0
        private void OnEnable()
        {
            m_disposelist = new List <IDisposable>();

            m_ScoreCalculator = m_ScoreCalculateObject.GetComponent <IScoreCalculator>();
            m_disposelist.Add(m_OnCellDeletedListener.Subscribe((num) =>
            {
                UpdateScore(num);
                if (m_UpdateHighScoreOnPlaying)
                {
                    UpdateHighScore();
                }
            }));

            m_disposelist.Add(m_PlayStartInitializeListener.Subscribe(PlayStartInitialize));
            if (!m_UpdateHighScoreOnPlaying)
            {
                m_disposelist.Add(m_UpdateHighScoreListener.Subscribe(UpdateHighScore));
            }
        }
Beispiel #22
0
    public void InitializeServices()
    {
        _cardSpawner = null ?? GetComponent <CardSpawner>();

        _sceneHandler = null ?? GetComponent <EndGameUI>();

        _hudManager = null ?? GetComponent <HUDManager>();

        _gameData = null ?? new GameDataManager();

        _pairChecker = null ?? new PairChecker();

        _serverCommunication = null ?? new ServerCommunications();

        _serializer = null ?? new JsonSerializer(saveFolder);

        _scoreCalculator = null ?? new ScoreCalculator();

        _scoreboardManager = null ?? new ScoreboardManager(_gameData, _scoreCalculator, _serializer);
    }
        public int GetScore()
        {
            _scoreCalculator = new ScoreCalculator();
            int frameIndex = 0;

            for (int frame = 0; frame < _numberOfFrames; frame++)
            {
                if (isSpare(frameIndex))
                {
                    _scoreCalculator.RollWithSpareFrame(rolls[frameIndex], rolls[frameIndex + 1]);
                    frameIndex += 2;
                }
                else if (isStrike(frameIndex))
                {
                    _scoreCalculator.RollWithStrikeFrame();
                    frameIndex++;
                }
                else
                {
                    _scoreCalculator.RollWithOpenFrame(rolls[frameIndex], rolls[frameIndex + 1]);
                    frameIndex += 2;
                }
            }

            // check if last frame is strik or spare by
            if (isStrike(frameIndex - 1))
            {
                _scoreCalculator.BonusRoll(rolls[frameIndex]);
                _scoreCalculator.BonusRoll(rolls[frameIndex + 1]);
            }
            else if (isSpare(frameIndex - 2))
            {
                _scoreCalculator.BonusRoll(rolls[frameIndex]);
            }
            return(_scoreCalculator.Score());
        }
Beispiel #24
0
 public HighscoreVM(IRepository repository, IScoreCalculator scoreCalculator)
 {
     _repository      = repository;
     _scoreCalculator = scoreCalculator;
 }
 public HomeController(ISessionFactory sessionFactory, IScoreCalculator calculator)
 {
     this.sessionFactory = sessionFactory;
     this.calculator = calculator;
 }
 public void Initialize()
 {
     _objectUnderTest = new ScoreCalculator();
 }
 public ComputerDealer(IShoeService shoeService, IScoreCalculator scoreCalculator)
     : base(shoeService, scoreCalculator)
 {
 }
 public HumanPlayer(IShoeService shoeService,
                    IScoreCalculator scoreCalculator,
                    string name = "")
     : base(shoeService, scoreCalculator, name)
 {
 }
 public CompetitionSummaryVM(IRepository repository, IScoreCalculator scoreCalculator)
 {
     _repository      = repository;
     _scoreCalculator = scoreCalculator;
 }
Beispiel #30
0
 public ScoreMultiplier(double multiply, IScoreCalculator scoreCalculator)
 {
     m_multiply        = multiply;
     m_scoreCalculator = scoreCalculator;
 }
    protected void PlayerYearData_Selecting(object sender, LinqDataSourceSelectEventArgs e)
    {
        if (reference == null)
        {
            reference = cbSeason.SelectedItem.Value;
        }

        IScoreCalculator calculator = CalculatorFactory.GetScoreCalculator(reference);


        var events = doc.Element("Fixtures").Elements("Fixture")
                     .Where(ee => (string)ee.Attribute("Season") == reference)
                     .Where(ee => (string)ee.Attribute("PlayerOfTheYear") == "True")
                     .OrderBy(ee => (string)ee.Attribute("Reference"))
                     .Select(ee =>
                             new
        {
            reference   = (string)ee.Attribute("Reference"),
            location    = (string)ee.Attribute("Location"),
            abbrevation = (string)ee.Attribute("Abbreviation")
        });


        List <string> evs = events.Select(ee => ee.abbrevation).ToList();


        List <PlayerYearInfo> PlayerOfTheYearTable = doc1.Element("Members").Elements("Member")
                                                     .Select(
            ee =>
            new PlayerYearInfo((string)ee.Attribute("Name"), evs,
                               calculator)).ToList();
        int counter = 0;

        foreach (var ev in events)
        {
            counter++;

            IEnumerable <XElement> results = doc.Element("Fixtures").Elements("Fixture")
                                             .Where(ee => (string)ee.Attribute("Reference") == ev.reference)
                                             .Descendants("Score")
                                             .Where(
                ff =>
                (string)
                ff.Ancestors("Result").SingleOrDefault().Attribute("PlayerOfTheYear") ==
                "True")
                                             .Select(ee => ee);

            foreach (XElement score in results)
            {
                PlayerYearInfo player = PlayerOfTheYearTable.Where(ee => ee.Player == (string)score.Attribute("Name"))
                                        .Select(ee => ee)
                                        .SingleOrDefault();

                if (player != null)
                {
                    player.RecordEvent(ev.abbrevation, (int)score.Attribute("Position"));
                }
            }
        }


        e.Result = PlayerOfTheYearTable.Where(ee => ee.Total > 0).OrderByDescending(ee => ee.Total).Select(ee => ee);
    }
 public ScoreDecorator(IScoreCalculator s)
 {
     this.scoreCalculator = s;
 }
 public HighscoreVM(IRepository repository, IScoreCalculator scoreCalculator)
 {
     _repository = repository;
     _scoreCalculator = scoreCalculator;
 }
Beispiel #34
0
 public BowlingGame(IFrameKeeper frameKeeper, IScoreCalculator calculator)
 {
     _frameKeeper = frameKeeper;
     _calculator = calculator;
 }
 public CompetitionSummaryVM(IRepository repository, IScoreCalculator scoreCalculator)
 {
     _repository = repository;
     _scoreCalculator = scoreCalculator;
 }
Beispiel #36
0
 public HomeController(ISessionFactory sessionFactory, IScoreCalculator calculator)
 {
     this.sessionFactory = sessionFactory;
     this.calculator     = calculator;
 }
Beispiel #37
0
 public void TestStart()
 {
     BestMoverChecker             = new BestMoveDepthSearch();
     scoreCalculator              = new StandardScoreCalculator();
     Constants.BonusPoints.Points = new List <(int, int)>();
 }
Beispiel #38
0
 public TournamentsService(DaprClient daprClient, ILogger <TournamentsService> logger, IScoreCalculator scoreCalculator, IConfiguration configuration) : base(daprClient, logger, configuration)
 {
     _scoreCalculator = scoreCalculator;
 }
Beispiel #39
0
 public SeedController(IRedisRepositoryString redisRepositoryString, IRedisRepositorySortedSet redisRepositorySortedSet, IScoreCalculator scoreCalculator)
 {
     _redisRepositoryString    = redisRepositoryString;
     _redisRepositorySortedSet = redisRepositorySortedSet;
     _scoreCalculator          = scoreCalculator;
 }