Ejemplo n.º 1
0
 /// <summary>
 /// Создание скобы по распределению
 /// </summary>
 /// <param name="d">Диаметр скобы</param>
 /// <param name="h">Длина нахлеста скобы - вылет (от внутренней грани стержня)</param>
 /// <param name="t">Ширина скобы (по внутренней грани стержня) - округляется до 5</param>
 /// <param name="step">Шаг скобы</param>
 /// <param name="width">Ширина распределения</param>
 /// <param name="pos">Позиция (из атрибута блока)</param>
 /// <param name="block">Блок</param>
 public Bracket(int d, int h, int t, int step, int width, int rows, string pos, ISpecBlock block, string friendlyName)
     : base(d, CalcLength(h, t, d), width, step, rows, PREFIX, pos, block, friendlyName)
 {
     T    = RoundHelper.Round5(t);
     L    = h;
     Key += "t" + T + "l" + L;
 }
Ejemplo n.º 2
0
    public List <GameObject> GetNearByBuilding(Vector3 position, int scope)
    {
        List <GameObject> result = new List <GameObject>();
        int distanceSqrt         = scope * scope;

        TilePosition tilePosition = PositionConvertor.GetActorTileIndexFromWorldPosition(position);
        int          radius       = Mathf.CeilToInt(scope / (float)Mathf.Min(ClientSystemConstants.ACTOR_TILE_MAP_TILE_SIZE.width,
                                                                             ClientSystemConstants.ACTOR_TILE_MAP_TILE_SIZE.height));
        List <TilePosition> affectedTiles = RoundHelper.FillCircle(tilePosition.Column, tilePosition.Row, radius);

        foreach (TilePosition tile in affectedTiles)
        {
            if (tile.IsValidActorTilePosition())
            {
                Vector2 p   = (Vector2)PositionConvertor.GetWorldPositionFromActorTileIndex(tile);
                Vector2 dis = p - (Vector2)position;
                if (dis.sqrMagnitude <= distanceSqrt)
                {
                    GameObject building = BattleMapData.Instance.GetBulidingObjectFromActorObstacleMap(tile.Row, tile.Column);
                    if (building != null && !result.Contains(building) && building.GetComponent <BuildingHPBehavior>() != null)
                    {
                        result.Add(building);
                    }
                }
            }
        }
        return(result);
    }
Ejemplo n.º 3
0
 public void AddCount(int count)
 {
     Count += count;
     // Масса всех стержней
     WeightTotal = RoundHelper.Round2Digits(Weight * Count);
     Amount      = WeightTotal;
 }
Ejemplo n.º 4
0
    public void activated()
    {
        // Destroy this dialog to close
        destroy();

        RoundHelper.MonsterActivated();
    }
Ejemplo n.º 5
0
        public void OrderPlayersTest()
        {
            var players = PlayersSetup.BuildFourAIPlayers();

            var first  = players[0];
            var second = players[1];
            var third  = players[2];
            var fourth = players[3];

            var afterFirst = RoundHelper.OrderPlayersForNewTrick(players, first);
            var newOrder   = string.Join("|", afterFirst.Select(t => t.PlayerNumber));

            Assert.AreEqual("0|1|2|3", newOrder);

            var afterSecond = RoundHelper.OrderPlayersForNewTrick(players, second);

            newOrder = string.Join("|", afterSecond.Select(t => t.PlayerNumber));
            Assert.AreEqual("1|2|3|0", newOrder);

            var afterThird = RoundHelper.OrderPlayersForNewTrick(players, third);

            newOrder = string.Join("|", afterThird.Select(t => t.PlayerNumber));
            Assert.AreEqual("2|3|0|1", newOrder);

            var afterFourth = RoundHelper.OrderPlayersForNewTrick(players, fourth);

            newOrder = string.Join("|", afterFourth.Select(t => t.PlayerNumber));
            Assert.AreEqual("3|0|1|2", newOrder);
        }
Ejemplo n.º 6
0
    private void Effect()
    {
        List <BuildingAI> affectedBuildings = new List <BuildingAI>();
        int distanceSqrt = this.Scope * this.Scope;

        Vector2      targetPosition = (Vector2)this.transform.position;
        TilePosition targetTile     = PositionConvertor.GetActorTileIndexFromWorldPosition(this.transform.position);
        int          radius         = Mathf.CeilToInt(this.Scope / (float)Mathf.Min(ClientSystemConstants.ACTOR_TILE_MAP_TILE_SIZE.width,
                                                                                    ClientSystemConstants.ACTOR_TILE_MAP_TILE_SIZE.height));

        List <TilePosition> affectedTiles = RoundHelper.FillCircle(targetTile.Column, targetTile.Row, radius);

        foreach (TilePosition tile in affectedTiles)
        {
            if (tile.IsValidActorTilePosition())
            {
                Vector2 p   = (Vector2)PositionConvertor.GetWorldPositionFromActorTileIndex(tile);
                Vector2 dis = p - targetPosition;
                if (dis.sqrMagnitude <= distanceSqrt)
                {
                    GameObject building = BattleMapData.Instance.GetBulidingObjectFromActorObstacleMap(tile.Row, tile.Column);
                    if (building != null)
                    {
                        BuildingAI ai = building.GetComponent <BuildingAI>();
                        if (ai != null && !affectedBuildings.Contains(ai))
                        {
                            affectedBuildings.Add(ai);
                            ai.SetTarget(this.gameObject, (Vector2)this.transform.position);
                        }
                    }
                }
            }
        }
    }
Ejemplo n.º 7
0
    // Use this for initialization
    void Start()
    {
//		this.m_DetectScopeSqr = this.m_DetectScope * this.m_DetectScope;
        this.m_DetectScopeList = RoundHelper.FillCircle(0, 0, Mathf.FloorToInt(this.m_DetectScope /
                                                                               Mathf.Min(ClientSystemConstants.ACTOR_TILE_MAP_TILE_SIZE.width,
                                                                                         ClientSystemConstants.ACTOR_TILE_MAP_TILE_SIZE.height)));
    }
    protected override void CalculateLightPositions(GameObject target, int targetRow, int targetColumn)
    {
        base.CalculateLightPositions(target, targetRow, targetColumn);
        IObstacleInfo property = this.m_MapData.GetObstacleInfoFormActorObstacleMap(targetRow, targetColumn);

        int radius = Mathf.FloorToInt(m_AttackScope /
                                      Mathf.Min(ClientSystemConstants.ACTOR_TILE_MAP_TILE_SIZE.width,
                                                ClientSystemConstants.ACTOR_TILE_MAP_TILE_SIZE.height));

        radius = Mathf.Max(0, radius - 1);
        foreach (TilePosition offset in property.ActorObstacleList)
        {
            TilePosition targetPosition = property.ActorPosition + offset;

            List <TilePosition> destinationTiles = RoundHelper.FillCircle(targetPosition.Column, targetPosition.Row, radius);
            foreach (TilePosition lightPosition in destinationTiles)
            {
                if (lightPosition.IsValidActorTilePosition())
                {
                    if (!this.m_PreviousTargetLightPositions.Contains(lightPosition.Column + (lightPosition.Row << 16)))
                    {
                        this.m_PreviousTargetLightPositions.Add(lightPosition.Column + (lightPosition.Row << 16));
                    }
                }
            }
        }
    }
    protected override void Calculate()
    {
        TilePosition        affectPosition = PositionConvertor.GetActorTileIndexFromWorldPosition(this.DestinationObject.GetDestinationPosition(this.transform.position));
        List <TilePosition> affectedTiles  = RoundHelper.FillCircle
                                                 (affectPosition.Column, affectPosition.Row, Mathf.CeilToInt(this.DamageScope /
                                                                                                             (float)Mathf.Min(ClientSystemConstants.ACTOR_TILE_MAP_TILE_SIZE.height,
                                                                                                                              ClientSystemConstants.ACTOR_TILE_MAP_TILE_SIZE.width)));

        foreach (TilePosition tile in affectedTiles)
        {
            if (tile.IsValidActorTilePosition())
            {
                List <GameObject> characters = BattleMapData.Instance.ActorArray[tile.Row, tile.Column];
                foreach (GameObject character in characters)
                {
                    CharacterPropertyBehavior property = character.GetComponent <CharacterPropertyBehavior>();
                    if (property.CharacterType == CharacterType.Invader)
                    {
                        //float distance = Vector2.Distance((Vector2)this.transform.position, (Vector2)character.transform.position);

                        //float percentage = (1 - distance) / this.m_GroupDamageScope;
                        //percentage = Mathf.Max(percentage, 0);

                        CharacterHPBehavior hpBehavior = character.GetComponent <CharacterHPBehavior>();
                        hpBehavior.DecreaseHP(this.Damage, this.AttackCategory);

                        this.PushCharacter(character);
                    }
                }
            }
        }
    }
Ejemplo n.º 10
0
        public sealed override ITicksInfo <DateTime> GetTicks(Range <DateTime> range, int ticksCount)
        {
            DateTime start  = range.Min;
            DateTime end    = range.Max;
            TimeSpan length = end - start;

            bool         isPositive = length.Ticks > 0;
            DifferenceIn diff       = difference;

            DateTime newStart = isPositive ? RoundDown(start, diff) : SafelyRoundUp(start);
            DateTime newEnd   = isPositive ? SafelyRoundUp(end) : RoundDown(end, diff);

            RoundingInfo bounds = RoundHelper.CreateRoundedRange(GetSpecificValue(newStart, newStart), GetSpecificValue(newStart, newEnd));

            int delta = (int)(bounds.Max - bounds.Min);

            if (delta == 0)
            {
                return new TicksInfo <DateTime> {
                           Ticks = new DateTime[] { newStart }
                }
            }
            ;

            int step = delta / ticksCount;

            if (step == 0)
            {
                step = 1;
            }

            DateTime tick          = GetStart(newStart, (int)bounds.Min, step);
            bool     isMinDateTime = IsMinDate(tick) && step != 1;

            if (isMinDateTime)
            {
                step--;
            }

            List <DateTime> ticks      = new List <DateTime>();
            DateTime        finishTick = AddStep(range.Max, step);

            while (tick < finishTick)
            {
                ticks.Add(tick);
                tick = AddStep(tick, step);
                if (isMinDateTime)
                {
                    isMinDateTime = false;
                    step++;
                }
            }

            TicksInfo <DateTime> res = new TicksInfo <DateTime> {
                Ticks = ticks.ToArray(), Info = diff
            };

            return(res);
        }
Ejemplo n.º 11
0
 public virtual void Start()
 {
     this.m_AttackConfig     = this.GetComponent <AttackConfig>();
     this.m_AttackScopeSqr   = this.AttackScope * this.AttackScope;
     this.m_AttackScopeArray = RoundHelper.FillCircle(0, 0, Mathf.CeilToInt(this.AttackScope /
                                                                            Mathf.Min(ClientSystemConstants.ACTOR_TILE_MAP_TILE_SIZE.width,
                                                                                      ClientSystemConstants.ACTOR_TILE_MAP_TILE_SIZE.height)));
 }
Ejemplo n.º 12
0
 /// <summary>
 /// Перед вызовом
 /// </summary>
 public override void Calc()
 {
     // Масса ед
     Weight = RoundHelper.Round3Digits(WeightUnit);
     // Масса общая
     WeightTotal = RoundHelper.Round2Digits(Weight * Meters);
     Amount      = WeightTotal;
 }
Ejemplo n.º 13
0
        public ITicksInfo <int> GetTicks(Range <int> range, int ticksCount)
        {
            double start  = range.Min;
            double finish = range.Max;

            double delta = finish - start;

            int log = (int)Math.Round(Math.Log10(delta));

            double newStart  = RoundHelper.Round(start, log);
            double newFinish = RoundHelper.Round(finish, log);

            if (newStart == newFinish)
            {
                log--;
                newStart  = RoundHelper.Round(start, log);
                newFinish = RoundHelper.Round(finish, log);
            }

            // calculating step between ticks
            double unroundedStep = (newFinish - newStart) / ticksCount;
            int    stepLog       = log;
            // trying to round step
            int step = (int)RoundHelper.Round(unroundedStep, stepLog);

            if (step == 0)
            {
                stepLog--;
                step = (int)RoundHelper.Round(unroundedStep, stepLog);
                if (step == 0)
                {
                    // step will not be rounded if attempts to be rounded to zero.
                    step = (int)unroundedStep;
                }
            }

            if (step < minStep)
            {
                step = minStep;
            }
            if (step > maxStep)
            {
                step = maxStep;
            }

            if (step <= 0)
            {
                step = 1;
            }

            int[] ticks = CreateTicks(start, finish, step);

            TicksInfo <int> res = new TicksInfo <int> {
                Info = log, Ticks = ticks
            };

            return(res);
        }
Ejemplo n.º 14
0
 /// <summary>
 /// Шпилька - с шагом по ширине распределения и кол рядов
 /// </summary>
 /// <param name="diam">Диам</param>
 /// <param name="lRab">Раст между раб стержнями (от центров раб стержней)</param>
 /// <param name="step">Шаг</param>
 /// <param name="width">Ширина распределения</param>
 /// <param name="rows">Рядов шпилек</param>
 /// <param name="pos">значение атр позиции</param>
 /// <param name="block">Блок</param>
 public Spring(int diam, int lRab, int step, int width, int rows, string pos, ISpecBlock block)
     : base(diam, GetLength(lRab, diam), width, step, rows, PREFIX, pos, block, friendlyName)
 {
     //descEnd = $", ш.{step}";
     tail  = getTail(diam);
     LRab  = RoundHelper.Round5(lRab);
     Class = ClassA240C;
     Gost  = GostOld;
 }
    private List <TilePosition> GetTilePositionList(int scope)
    {
        TilePosition actorPosition = PositionConvertor.GetActorTileIndexFromWorldPosition
                                         (this.m_Property.AnchorTransform.position);
        int radius = Mathf.CeilToInt(scope / (float)Mathf.Min(ClientSystemConstants.ACTOR_TILE_MAP_TILE_SIZE.width,
                                                              ClientSystemConstants.ACTOR_TILE_MAP_TILE_SIZE.height));

        return(RoundHelper.FillCircle(actorPosition.Column, actorPosition.Row, radius));
    }
Ejemplo n.º 16
0
 /// <summary>
 /// Хомут
 /// </summary>
 /// <param name="diam">Диаметр</param>
 /// <param name="wShackle">Ширина хомута (по внутр гряням)</param>
 /// <param name="hShackle">Высота хомута</param>
 /// <param name="step">Шаг</param>
 /// <param name="range">Ширина распределения</param>
 /// <param name="pos">Значение атр позиции из блока</param>
 /// <param name="block">Блок</param>
 public Shackle(int diam, int wShackle, int hShackle, int step, int range, int rows, string pos, ISpecBlock block)
     : base(diam, GetLenShackle(wShackle, hShackle, diam), range, step, rows, PREFIX, pos, block, friendlyName)
 {
     tail  = getTail(diam);
     L     = RoundHelper.Round5(wShackle);
     H     = RoundHelper.Round5(hShackle);
     Class = ClassA240C;
     Gost  = GostOld;
     Key   = GetName() + "t" + tail + "L" + L + "h" + H;
 }
Ejemplo n.º 17
0
    // Null function for activated hero
    public void activated()
    {
        destroy();
        hero.activated = true;

        // Let the game know that a hero has activated
        RoundHelper.HeroActivated();

        updateDisplay();
    }
Ejemplo n.º 18
0
 /// <summary>
 /// Шпилька распределенная по площади стены
 /// </summary>
 /// <param name="diam">Диаметр шпильки</param>
 /// <param name="diamWork">Диам раб арм</param>
 /// <param name="lRab">Раст между раб стержнями (от центров раб стержней)</param>
 /// <param name="stepHor">Шаг шпилек по горизонтали</param>
 /// <param name="stepVert">Шаг шпилек по вертикали</param>
 /// <param name="widthHor">Ширина распределения по гориз</param>
 /// <param name="widthVertic">Ширина распр по вертик</param>
 /// <param name="pos">Позиция (из атр блока)</param>
 /// <param name="block">Блок</param>
 public Spring(int diam, int lRab, int stepHor, int stepVert, int widthHor, int widthVertic, string pos, ISpecBlock block)
     : base(diam, GetLength(lRab, diam), 1, PREFIX, pos, block, friendlyName)
 {
     Step            = stepHor;
     this.stepVertic = stepVert;
     //descEnd = $", ш.{stepHor}х{stepVert}";
     tail  = getTail(diam);
     LRab  = RoundHelper.Round5(lRab);
     Class = ClassA240C;
     Gost  = GostOld;
     Count = CalcCountByArea(widthHor, widthVertic, stepHor, stepVert);
     Key   = GetName() + "t" + tail + "lr" + LRab;
 }
Ejemplo n.º 19
0
 public virtual void Calc()
 {
     // Кол стержней
     if (Width != 0 && Step != 0)
     {
         Count = CalcCountByStep(Width, Step) * Rows;
     }
     // Масса ед. кг.
     Weight = RoundHelper.Round3Digits(WeightUnit * ConvertMmToMLength(Length));
     // Масса всех стержней
     WeightTotal = RoundHelper.Round2Digits(Weight * Count);
     Amount      = WeightTotal;
 }
Ejemplo n.º 20
0
    public override void Start()
    {
        base.Start();

        List <TilePosition> blindArray = RoundHelper.FillCircle(0, 0, Mathf.FloorToInt(this.m_BlindScope /
                                                                                       Mathf.Min(ClientSystemConstants.ACTOR_TILE_MAP_TILE_SIZE.width,
                                                                                                 ClientSystemConstants.ACTOR_TILE_MAP_TILE_SIZE.height)));

        foreach (TilePosition b in blindArray)
        {
            this.AttackScopeArray.Remove(b);
        }
    }
Ejemplo n.º 21
0
        public void Play()
        {
            Trump = SuitHelper.GetSuit("Heart");
            var trick = new Trick(Players, Trump);

            for (int i = 0; i < BelotteRules.TrickNumber; i++)
            {
                trick.Play(CardsHeldByPlayers, CardsPlayedByPlayers);

                var newPlayersOrder = RoundHelper.OrderPlayersForNewTrick(Players, trick.GetTaker());
                LastTrickWinner = trick.GetTaker();
                trick           = new Trick(newPlayersOrder, Trump);
            }
        }
Ejemplo n.º 22
0
        public void SetNewTimerInterval()
        {
            int interval = new DbHelper().SelectNextInterval();

            if (interval < 0)
            {
                interval = m_sleepTick;
            }
            if (interval == 0)
            {
                interval = 1;
            }
            m_log.DebugFormat("Picked new timer interval which is {0} ms ({1} min.)",
                              interval, RoundHelper.Round(interval / 1000.0m / 60.0m, 2));
            m_timer.Interval = interval;
        }
Ejemplo n.º 23
0
        public Task <decimal> CalculateTaxAsync(Item item, int count)
        {
            var     subtotal = item.Price * count;
            decimal tax      = 0;

            if (!item.IsExemptFromBasicSalesTax)
            {
                tax += RoundHelper.RoundToNearest(subtotal * this.salesTax, TaxRoundsUpTo);
            }

            if (item.IsImported)
            {
                tax += RoundHelper.RoundToNearest(subtotal * this.importTax, TaxRoundsUpTo);
            }

            return(Task.FromResult(subtotal + tax));
        }
Ejemplo n.º 24
0
        public string FormatNextTaskRemindingDate()
        {
            int    maxTimeTextLength = 38; // Text length without task description
            int    maxLength         = 64; // for NotifyIcon.Text property it's maximum
            int    maxTaskNameLength = maxLength - maxTimeTextLength;
            string text     = "Nothing to be mindered about";
            Task   nextTask = new DbHelper().NextTaskToShow();

            if (nextTask == null)
            {
                return(text);
            }
            if (string.IsNullOrEmpty(nextTask.Text) == false &&
                nextTask.Text.Length > maxTaskNameLength)
            {
                nextTask.Text = nextTask.Text.Substring(0, maxTaskNameLength);
            }
            DateTime?nextDate = nextTask.DateRemainder;

            if (nextDate.HasValue == false)
            {
                return(text);
            }

            text = string.Format("Task {0} minders at {1}", nextTask.Text, DBTypesConverter.ToFullDateStringByCultureInfo(nextDate.Value));
            TimeSpan difference = nextDate.Value.Subtract(DateTime.Now);

            decimal days = RoundHelper.Round((decimal)difference.TotalDays, 0);

            if (days < 1)
            {
                text = string.Format("Task {0} minders at {1}", nextTask.Text, nextDate.Value.ToShortTimeString());
            }

            decimal minutes = RoundHelper.Round((decimal)difference.TotalMinutes, 0);

            if (difference.TotalHours < 1)
            {
                text = string.Format("Task {0} minders in {1} minutes", nextTask.Text, minutes);
            }
            if (minutes < 1)
            {
                text = (string.Format("Task {0} minders in less than a minute", nextTask.Text));
            }
            return(text);
        }
Ejemplo n.º 25
0
 private void AutoAdjustCoordinate()
 {
     if (this.Points.Length != 0)
     {
         this.CalcXYZRange();
         _roundZRange     = RoundHelper.CreateRoundedRange(this.ZRange.Min, this.ZRange.Max);
         _axisGrid.XRange = RoundHelper.CreateRoundedRange(this.XRange.Min, this.XRange.Max);
         _axisGrid.YRange = RoundHelper.CreateRoundedRange(this.YRange.Min, this.YRange.Max);
         if (_roundZRange.Min == _roundZRange.Max)
         {
             _axisGrid.ZRange = new Range <double>(_roundZRange.Max / 2.0, _roundZRange.Max);
         }
         else
         {
             _axisGrid.ZRange = _roundZRange;
         }
     }
 }
Ejemplo n.º 26
0
        private string GetRoundedValue(double min, double max, double value)
        {
            double roundedValue = value;
            var    log          = RoundHelper.GetDifferenceLog(min, max);
            string format       = "G3";
            double diff         = Math.Abs(max - min);

            if (1E3 < diff && diff < 1E6)
            {
                format = "F0";
            }
            if (log < 0)
            {
                format = "G" + (-log + 2).ToString();
            }

            return(roundedValue.ToString(format));
        }
Ejemplo n.º 27
0
        /// <summary>
        /// Initializes a new instance of the Test2 class.
        /// </summary>
        public Test2()
        {
            InitializeComponent();

            var range = RoundHelper.CreateRoundedRange(2.1, 3.5);

            double a  = 10.2;
            double b  = 1;
            var    ia = (int)a;
            var    ib = (int)b;

            ia = ia - (ia + ib) % ib;
            var c = a + b / 2;

            var d = c % b;

            a = a - d;
        }
        public ITicksInfo <double> GetTicks(Range <double> range, int ticksCount)
        {
            double min = LogByBase(range.Min);
            double max = LogByBase(range.Max);

            double minDown = Math.Floor(min);
            double maxUp   = Math.Ceiling(max);

            double logLength = LogByBase(range.GetLength());

            ticks = CreateTicks(range);

            int log = RoundHelper.GetDifferenceLog(range.Min, range.Max);
            TicksInfo <double> result = new TicksInfo <double> {
                Ticks = ticks, TickSizes = ArrayExtensions.CreateArray(ticks.Length, 1.0), Info = log
            };

            return(result);
        }
Ejemplo n.º 29
0
        private Range <double> CreateRangeOfZAxis()
        {
            double minZ = Data[0, 0].Z, maxZ = Data[0, 0].Z;

            for (int i = 0; i <= Data.GetUpperBound(0); i++)
            {
                for (int j = 0; j <= Data.GetUpperBound(1); j++)
                {
                    if (Data[i, j].Z < minZ)
                    {
                        minZ = Data[i, j].Z;
                    }
                    else
                    if (Data[i, j].Z > maxZ)
                    {
                        maxZ = Data[i, j].Z;
                    }
                }
            }

            return(RoundHelper.CreateRoundedRange(minZ, maxZ));
        }
Ejemplo n.º 30
0
        private void CreateNewRound()
        {
            if (txt_Motion.ReadOnly)
            {
                txt_Motion.ReadOnly = false;
                txt_Motion.Text     = string.Empty;
                dgv_Round.Visible   = false;

                MessageBox.Show("Enter the motion for debate in this round");
                return;
            }

            string motion = txt_Motion.Text;

            if (string.IsNullOrWhiteSpace(motion))
            {
                MessageBox.Show("Please enter a motion for debate in this round");
                return;
            }

            if (_context.Speakers.Count(s => s.Active) % 6 != 0)
            {
                MessageBox.Show(string.Format("There are an incorrect number of speakers active to draw a round. You require either {0} or {1} and you currently have {2}", Math.Floor(((decimal)_context.Speakers.Count(s => s.Active) / 6 - 1) * 6), Math.Ceiling(((decimal)_context.Speakers.Count(s => s.Active) / 6 + 1) * 6), _context.Speakers.Count(s => s.Active)));
                return;
            }

            if (_context.Speakers.Count / 6 > _context.Venues.Count(v => v.Active))
            {
                MessageBox.Show(string.Format("There are not enough venues active to draw a round. You require {0} and you currently have {1}.", _context.Speakers.Count(s => s.Active) / 6, _context.Venues.Count(v => v.Active)));
                return;
            }

            bool  isPowerPaired = chk_Powerpair.Checked;
            Round round         = RoundHelper.DrawRound(_tournament, motion, isPowerPaired);

            LoadRounds();
            cmb_Rounds.SelectedIndex = cmb_Rounds.Items.Count - 1;
            LoadRound();
        }