public Boggle(ScoringMode score_mode = ScoringMode.SCRABBLE, BoardSize board_size = BoardSize.BIGBOGGLE, BoundaryMode bound_mode = BoundaryMode.STANDARD, int time_limit = 180000, int min_length = 3) { status = GameStatus.PRE_GAME; score = 0; mode = score_mode; size = board_size; minLength = min_length; gameLength = time_limit; bound = bound_mode; dice = new string[(int)size, 6]; //Create the array to hold dice values position = new int[(int)size]; //Array of positions on board board = new string[(int)size]; //Array containing the layout of the board gameTimer.Enabled = false; gameTimer.Interval = (double)gameLength; gameTimer.Elapsed += new ElapsedEventHandler(OnTimedEvent); current_word_list = "../../enable2k.txt"; if (size == BoardSize.STANDARD) { current_dice_set = "../../BoggleDice.txt"; } else { current_dice_set = "../../BigBoggleDice.txt"; } LoadDice(); LoadWordList(); ShuffleBoard(); }
public ContainsResult(Field tip, bool contain, Vector2 layerPoint, BoundaryMode boundary = BoundaryMode.Unknown) { this.tip = tip; this.boundary = boundary; this.contain = contain; this.layerPoint = layerPoint; }
public bool IsCrossOver(float threshold, BoundaryMode boundaryMode = BoundaryMode.High) { switch (boundaryMode) { case BoundaryMode.Low: return((Previous < threshold && threshold <= Current) || (Current < threshold && threshold <= Previous)); case BoundaryMode.High: return((Previous <= threshold && threshold < Current) || (Current <= threshold && threshold < Previous)); } throw new Exception("BoundaryMode must be High or Low."); }
void SetBoundaries(float [,] grid, BoundaryMode mode) { for (int x = 1; x < FluidDataBank.GRID_WIDTH - 1; ++x) { grid[x, 0] = grid[x, 1] * ((mode == BoundaryMode.MirrorVertical) ? -1 : 1); grid[x, FluidDataBank.GRID_HEIGHT - 1] = grid[x, FluidDataBank.GRID_HEIGHT - 2] * ((mode == BoundaryMode.MirrorVertical) ? -1 : 1); } for (int y = 1; y < FluidDataBank.GRID_HEIGHT - 1; ++y) { grid[0, y] = grid[1, y] * ((mode == BoundaryMode.MirrorHorizontal) ? -1 : 1); grid[FluidDataBank.GRID_WIDTH - 1, y] = grid[FluidDataBank.GRID_WIDTH - 2, y] * ((mode == BoundaryMode.MirrorHorizontal) ? -1 : 1); } grid[0, 0] = 0.5f * (grid[0, 1] + grid[1, 0]); grid[FluidDataBank.GRID_WIDTH - 1, 0] = 0.5f * (grid[FluidDataBank.GRID_WIDTH - 2, 0] + grid[FluidDataBank.GRID_WIDTH - 1, 1]); grid[0, FluidDataBank.GRID_HEIGHT - 1] = 0.5f * (grid[0, FluidDataBank.GRID_HEIGHT - 2] + grid[1, FluidDataBank.GRID_HEIGHT - 1]); grid[FluidDataBank.GRID_WIDTH - 1, FluidDataBank.GRID_HEIGHT - 1] = 0.5f * (grid[FluidDataBank.GRID_WIDTH - 2, FluidDataBank.GRID_HEIGHT - 1] + grid[FluidDataBank.GRID_WIDTH - 1, FluidDataBank.GRID_HEIGHT - 2]); }
public TimelineSearchResult <T> Search(float rate, BoundaryMode boundaryMode = BoundaryMode.High) { if (dataArray.Count == 0) { throw new Exception("timeline is not initialized"); } var searchResult = weightArray.FloatBinarySearch(rate * TotalWeight, boundaryMode); float baseWeight; if (searchResult == 0) { baseWeight = 0; } else { baseWeight = weightArray[searchResult - 1] / TotalWeight; } float nextWeight; if (searchResult == dataArray.Count - 1) { nextWeight = 1; } else { nextWeight = weightArray[searchResult] / TotalWeight; } return(new TimelineSearchResult <T>( dataArray[searchResult], searchResult, baseWeight, nextWeight )); }
private void radBoundStandard_CheckedChanged(object sender, EventArgs e) { if (radBoundStandard.Checked) { boundMode = BoundaryMode.STANDARD; } }
private void radBoundPeriod_CheckedChanged(object sender, EventArgs e) { if (radBoundPeriod.Checked) { boundMode = BoundaryMode.PERIODIC; } }
void Advect(float[,] destination, float[,] source, float[,] velocityX, float[,] velocityY, BoundaryMode boundaryMode, float deltaTime) { // Instead of taking an explicit "integrate forward" approach, we do this implicit-style by tracing backwards from each cell center;\ // since this requires us to compute a source value between cell centers, we simply linearly interpolate between the four neighbouring cells for (int x = 1; x < FluidDataBank.GRID_WIDTH - 1; ++x) { for (int y = 1; y < FluidDataBank.GRID_HEIGHT - 1; ++y) { float sampleX = x - deltaTime * velocityX[x, y]; float sampleY = y - deltaTime * velocityY[x, y]; int leftX; int rightX; int bottomY; int topY; float alphaX; float alphaY; GridCoordinatesToInterpolationParameters(sampleX, sampleY, out leftX, out rightX, out bottomY, out topY, out alphaX, out alphaY); destination[x, y] = SampleGrid(source, leftX, rightX, bottomY, topY, alphaX, alphaY); } } SetBoundaries(destination, boundaryMode); }
void Relax(float[,] destination, float[,] source, int numIterations, float alpha, BoundaryMode boundaryMode, float deltaTime) { CopyGrid(destination, source); var k = alpha * deltaTime; // Gauss-Siedel relaxation of the target density matrix for (int iteration = 0; iteration < numIterations; ++iteration) { for (int x = 1; x < FluidDataBank.GRID_WIDTH - 1; ++x) { for (int y = 1; y < FluidDataBank.GRID_HEIGHT - 1; ++y) { destination[x, y] = (source[x, y] + k * (destination[x - 1, y] + destination[x + 1, y] + destination[x, y - 1] + destination[x, y + 1])) / (1 + 4 * k); } } } SetBoundaries(destination, boundaryMode); }
public BoggleGUI(Options c, Color valid_move, Color selected_move, ScoringMode score_mode = ScoringMode.SCRABBLE, BoardSize board_size = BoardSize.BIGBOGGLE, BoundaryMode bound_mode = BoundaryMode.STANDARD, int t_limit = 180000, int min_length = 3) { InitializeComponent(); caller = (Options)c; colorValid = valid_move; colorSelected = selected_move; scoreMode = score_mode; boardSize = board_size; boundMode = bound_mode; timeLimit = t_limit; wordMin = min_length; string dice = caller.customDice; string word = caller.customWords; //Create psuedo control array btnArray = new Button[(int)boardSize]; btnArray[0] = button1; btnArray[1] = button2; btnArray[2] = button3; btnArray[3] = button4; btnArray[4] = button5; btnArray[5] = button6; btnArray[6] = button7; btnArray[7] = button8; btnArray[8] = button9; btnArray[9] = button10; btnArray[10] = button11; btnArray[11] = button12; btnArray[12] = button13; btnArray[13] = button14; btnArray[14] = button15; btnArray[15] = button16; if (boardSize == BoardSize.BIGBOGGLE) // If Big Boggle need all the buttons { btnArray[16] = button17; btnArray[17] = button18; btnArray[18] = button19; btnArray[19] = button20; btnArray[20] = button21; btnArray[21] = button22; btnArray[22] = button23; btnArray[23] = button24; btnArray[24] = button25; } else // Else if Standard hide the extra buttons { button17.Visible = false; button18.Visible = false; button19.Visible = false; button20.Visible = false; button21.Visible = false; button22.Visible = false; button23.Visible = false; button24.Visible = false; button25.Visible = false; int btnNumber = 0; for (int row = 0; row < 4; row++) //Rearrange the buttons into a 4x4 grid { for (int col = 0; col < 4; col++) { Point myPoint = new Point(41 * (col % 4), (41 * row)); btnArray[btnNumber].Location = myPoint; btnNumber++; } } } }
// ================================================= // Float Array // ================================================= ///<summary> ///<returns>0 to sortedValues.Count integer</returns> ///</summary> public static int FloatBinarySearch(this IList <float> sortedValues, float value, BoundaryMode boundaryMode = BoundaryMode.Low) { var min = 0; var max = sortedValues.Count; if (boundaryMode == BoundaryMode.Low) { while (true) { var next = (max - min) / 2 + min; var dv = sortedValues[next]; if (dv <= value) { min = next + 1; } else { max = next; } if (min == max) { break; } } } else { while (true) { var next = (max - min) / 2 + min; var dv = sortedValues[next]; if (dv < value) { min = next + 1; } else { max = next; } if (min == max) { break; } } } return(min); }
private void ValidateBoundary(BoundaryMode comparisonMode, int comparisonResult, object parameterValue, string parameterName) { if (comparisonResult < 0 || (comparisonResult == 0 && comparisonMode == BoundaryMode.Exclusive)) { ValidationFailed(null, parameterValue, parameterName); } }