MA 310 Mathematical Programming 2 - Fall 2025

Description.

Signature.

Specifications.

• Use a switch statement on difficulty to assign:

  • gridSize — number of tiles per side.
    🔗
  • pctMines — mine percentage for the selected difficulty.
    🔗
  • timeLimit — countdown duration in seconds (“inf” means no timer).
    🔗

  The default (otherwise) case uses the brutal settings.

  🔗
  🔗
• The built-in difficulty presets are:

  🔗

  Mode	Grid Size	Mine Fraction	Time Limit
  “test”	\(5\times 5\)	\(0.10\)	\(30\) seconds
  “easy”	\(10\times 10\)	\(0.10\)	♾️ (no timer)
  “normal”	\(15\times 15\)	\(0.13\)	\(160\) seconds
  “hard”	\(20\times 20\)	\(0.16\)	\(100\) seconds
  “brutal” (default)	\(20\times 20\)	\(0.18\)	\(80\) seconds

  🔗
• Compute the total number of mines using pctMines and gridSize. Make sure to round this number to the nearest integer.
  🔗
• The settings struct must contain the following fields:

  🔗

  gridSize	\((1\times 1)\) integer 🔗 Number of tiles on each side of the board. 🔗
  figPosition	\((1\times 4)\) double 🔗 Figure position vector \([x_0, y_0, w, h]\) used by init_gui to size and place the window. In the provided implementation, the width w scales with gridSize so that tiles remain roughly square. 🔗
  nMines	\((1\times 1)\) integer 🔗 Total number of mines on the board. 🔗
  icons	\((1\times 1)\) struct 🔗 Emoji-based icons used throughout the GUI: 🔗 These are consumed by init_gui, update_zoneLabels, and the explosion animation. 🔗
  sizes	\((1\times 1)\) struct 🔗 Font sizes for different GUI elements: 🔗
  colors	\((8\times 3)\) double 🔗 RGB colors for the numbers \(1\) through \(8\) on revealed tiles. The default palette is designed to resemble classic Minesweeper colors. 🔗
  timeLimit	\((1\times 1)\) double 🔗 Maximum time, in seconds, for the game. Use inf for no time limit (for example, on “easy”). 🔗
  explosionDelay	\((1\times 1)\) double 🔗 Pause between clicking a mine and beginning the explosion animation (Tier 3 feature). The demo uses \(3.5\) seconds. 🔗

  🔗
• Regardless of whether you complete the 🏆 features, all of the fields described should be present in your settings output.
  🔗

Helpers Used.

Examples.

% Example 1 — Normal difficulty
settings = init_settings("normal");
settings.gridSize		% returns 15
settings.nMines			% returns round(0.13 * 225)
settings.timeLimit		% returns 160
size(settings.colors)	% returns [8 3]
settings.figPosition	% 1x4 vector for the figure position

% Example 2 — Unrecognized difficulty → Brutal mode
settings = init_settings("banana");
settings.gridSize		% returns 20
settings.nMines			% returns 72
settings.timeLimit		% returns 80
settings.explosionDelay	% default: 3.5 seconds

Description.

Signature.

Specifications.

• This helper builds a struct that stores the (possibly changing) values of current game: mine locations, revealed tiles, flagged tiles, etc..
  🔗
• The fields of state are described and initialized as follows:

  isMine	\((N \times N)\) logical ➟ Default: all false 🔗 Indicates if the \((r,c)\)-tile hides a Mine. 🔗
  minesNearBy	\((N \times N)\) integer ➟ Default: all 0 🔗 Number of Mines touching the \((r,c)\)-tile (up to 8). 🔗
  flagged	\((N \times N)\) logical ➟ Default: all false 🔗 Indicates if the \((r,c)\)-tile is flagged. 🔗
  revealed	\((N \times N)\) logical ➟ Default: all false 🔗 Indicates if the \((r,c)\)-tile has been revealed. 🔗
  gameStarted 🔗	\((1 \times 1)\) logical ➟ Default: false 🔗 Signals that the first tile has been clicked. 🔗
  gameOver	\((1 \times 1)\) logical ➟ Default: false 🔗 Signals if the game is over (win, loss, or time-out). 🔗
  playerWon	\((1 \times 1)\) logical ➟ Default: false 🔗 Signals if the player has successfully cleared the board. 🔗
  startTime	\((1 \times 1)\) double ➟ Default: 0 🔗 Starting time stamp (returned by tic) after first-click. 🔗
  timesUp	\((1 \times 1)\) logical ➟ Default: false 🔗 Signals if the time limit has been reached. 🔗

  🔗
  🔗
• Regardless of whether you complete the 🏆 features, all of the fields described should be present in your settings output.
  🔗

Helpers Used.

Examples.

% Example 1: Small grid
state = init_state(2);

% Check a few sample values:
state.isMine			% ← 2x2 logical with all false
state.minesNearBy		% ← 2x2 with all 0
state.flagged			% ← 2x2 logical with all false
state.revealed			% ← 2x2 logical with all false
state.gameStarted		% ← false
state.startTime			% ← 0
state.playerWon			% ← false

% Example 2: Large grid
state = init_state(18);

% Check a few sample values:
size(state.isMine)	% ← [18 18]
state.minesNearBy	% ← 18x18, all 0
state.gameOver		% ← false

Description.

Signature.

Specifications.

• The goal of this helper is two-fold:

  • Construct the gui structure that stores handles to all on–screen components.
    🔗
  • Set up a configured figure window fig that contains the Minesweeper board.
    🔗

  🔗
  🔗
• This helper is responsible only for the visual layout and assigning which functions will be called when a component is clicked. It does not place any mines, compute proximity numbers, or check win/loss conditions.
  🔗
• You will need the following values from settings:

  🔗
  gridSize — figPosition — icons — sizes

  🔗
  🔗
• GUI components:

  🔗

  zoneLbls	\((N\times N)\) text 🔗 Text label displaying the mine counts or mine icons. 🔗 Minimum Properties: Position ➟ center of grid space location 🔗 String ➟ empty (may change) 🔗 FontSize ➟ label size 🔗 FontWeight ➟ bold 🔗 HorizontalAlignment ➟ center 🔗 Visible ➟ true 🔗 🔗
  tiles	\((N\times N)\) text 🔗 Text label displaying the tile icons. 🔗 Minimum Properties: Position ➟ center of grid space location 🔗 String ➟ tile icon 🔗 FontSize ➟ tile size 🔗 FontWeight ➟ bold 🔗 HorizontalAlignment ➟ center 🔗 Visible ➟ true 🔗 ButtonDownFcn ➟ clicked_on_tile helper 🔗 🔗
  flags	\((N\times N)\) text 🔗 Text label displaying flag icons drawn on top of tiles. 🔗 Minimum Properties: Position ➟ center of grid space location 🔗 String ➟ flag icon 🔗 FontSize ➟ flag size 🔗 FontWeight ➟ bold 🔗 HorizontalAlignment ➟ center 🔗 Visible ➟ false (initially) 🔗 ButtonDownFcn ➟ clicked_on_tile helper 🔗 🔗
  resetButton	\((1\times 1)\) text 🔗 Text label displaying the reset icon below the grid. 🔗 Minimum Properties: Position ➟ below the grid 🔗 String ➟ reset icon 🔗 FontSize ➟ reset size 🔗 HorizontalAlignment ➟ Your choice 🔗 Visible ➟ true 🔗 ButtonDownFcn ➟ reset_game helper 🔗 🔗
  resultsLabel	\((1\times 1)\) text 🔗 Status text used to show feedback at the end of the game. 🔗 Minimum Properties: Position ➟ below the grid 🔗 String ➟ empty (may change) 🔗 FontSize ➟ label size 🔗 HorizontalAlignment ➟ left 🔗 Visible ➟ true 🔗 🔗
  timeLabel \(^{🏆}\)	\((1\times 1)\) text 🔗 Text label used to display remaining time. 🔗 Minimum Properties: Position ➟ below the grid 🔗 String ➟ "Time: " + timeLimit or "Time: ♾️" 🔗 FontSize ➟ label size 🔗 HorizontalAlignment ➟ left 🔗 Visible ➟ true 🔗 🔗

  🔗
• Use a nested loop to initialize zoneLbls, tiles, and flags matrices as described above. Before you do, preallocate them with gobjects(N, N).
  🔗
• Set up the figure window as follows (up to minor cosmetic changes):

  🔗

  fig = figure;
  fig.Position = position;
  fig.ToolBar  = "none";
  fig.MenuBar  = "none";
  title("Mine Sweeper", "FontSize", 18)
  xlim([1 N+1]); ylim([1 N+1]);
  axis off
  axis square
  axis ij     % orients the positive y-axis downward
  

  🔗
• After calling init_gui, the board should show an \(N\times N\) array of covered tiles, a reset icon, and empty status/timer labels. Mines and numbers remain hidden until other helpers update them.
  🔗

Helpers Used.

Examples.

% Create an "easy" Minesweeper GUI.
settings = init_settings("easy");
[gui, fig] = init_gui(settings);
% The window should show a 10-by-10 grid of covered tiles,
% a reset icon, and a timer label reading either "Time: ♾️"
% or a numeric time, depending on the difficulty.

Description.

Signature.

Specifications.

• The task of this helper is to return all neighboring grid locations adjacent (horizontally, vertically, or diagonally) to tile \((r,c)\text{.}\)
  🔗
• The output matrix has exactly one row per neighbor, and each row contains \([\text{row}, \text{col}]\text{.}\)
  🔗
• This helper does not inspect Mines, flags, or reveal status. It is purely geometric and is reused by several other helpers, including:

  • get_mineCounts — to count Mines in adjacent cells,
    🔗
  • reveal_tiles — to propagate a flood-fill reveal,
    🔗
  • any logic that requires adjacency relationships.
    🔗

  🔗
  🔗

Helpers Used.

Examples.

% Example 1: Corner tile on a 5×5 board
neighbors = get_neighbors(1, 1, 5)
% Expected: three neighbors
%     1		2
%     2		1
%     2		2

% Example 2: Center tile on a 10×10 board
neighbors = get_neighbors(5, 5, 10)
% Expected: eight neighbors
%     4 	4
%     4 	5
%     4 	6
%     5 	4
%     5 	6
%     6 	4
%     6 	5
%     6 	6

Description.

Signature.

Specifications.

• The task of this helper is to randomly generate and place Mines on the board while avoiding the initial safe click at (initRow, initCol).
  🔗
• Use the configuration from g.settings:

  • N = g.settings.gridSize — board dimension.
    🔗
  • M = g.settings.nMines — total Mines to place.
    🔗

  🔗
  🔗
• Implement Mine placement using a rejection-sampling loop:

  • Begin with a logical matrix mines of size \(N \times N\) initialized to false.
    🔗
  • Temporarily mark the initial click location as blocked: mines(initRow, initCol) = true.
    🔗
  • For k = 1:M, repeatedly generate random row/column indices using randi(N) until you find a location that does not already contain a Mine.
    🔗
  • Place a Mine there by setting mines(row, col) = true.
    🔗

  🔗
  🔗
• After all Mines are placed, clear the temporary block at (initRow, initCol) by setting mines(initRow, initCol) = false.
  🔗
• Finally, assign the completed layout back into the game structure: g.state.isMine = mines.
  🔗

Helpers Used.

Examples.

% Setup a reproducible testing environment:
rng(7,"twister");
g.settings = init_settings("easy");
g.state    = init_state(g.settings.gridSize);

% Example: Player clicked the (row=7, col=5) location
clickedRow = 7;
clickedCol = 5;
mines = get_mines(g, clickedRow, clickedCol);

% Check:
%   - mines is a 10x10 logical array.
%   - Exactly g.settings.nMines entries are true.
%   - mines(7,5) is false.

Description.

Signature.

Specifications.

• The task of this helper is to compute the proximity numbers on the game board as an \(N \times N\) integer matrix and store it in g.state.minesNearBy.
  🔗
• This helper assumes that the Mine layout g.state.isMine has already been generated by get_mines.
  🔗
• Use nested loops to scan through each (r,c)-tile on the grid.
  🔗
• For each (r,c)-tile:

  • If there is a mine there, skip it.
    🔗
  • Otherwise, count the number of mines in the surrounding \(3 \times 3\) area.
    🔗
  • Ignore the center tile itself.
    🔗

  🔗
  🔗
• Be careful not access values outside the bounds of the matrix.
  🔗

Helpers Used.

Examples.

% Example 1: Compute mine counts on a small test board.
% Setup a small test board:
g.settings = init_settings("test");
g.state = init_state(g.settings.gridSize);

% First, hardcode some mine locations:
g.state.isMine = [ ...
		true	true	false   false   false; ...
		true	false   false   false   false; ...
		false   true	true	false   true; ...
		false   false   false   false   true; ...
		false   true	false   false   true; ...
];
% View the mines as 1s and 0s:
g.state.isMine
% Returns: 
%	5x5 logical array
%	  1   1   0   0   0
%	  1   0   0   0   0
%	  0   1   1   0   1
%	  0   0   0   0   1
%	  0   1   0   0   1

counts = get_mineCounts(g)
% Returns:
% counts =
%	  0   0   1   0   0
%	  0   5   3   2   1
%	  2   0   0   3   0
%	  2   3   3   4   0
%	  1   0   1   2   0

Description.

Signature.

Specifications.

• The task of this helper is to update the text labels inside g.gui.zoneLabels with either a Mine icon or a Mine-proximity number for each tile.
  🔗
• An optional, but helpful step is to extract the data needed in this helper:

  • N = g.settings.gridSize
    🔗
  • icons = g.settings.icons (especially icons.mine)
    🔗
  • colors = g.settings.colors — the 8 colors for numbers 1-8
    🔗
  • isMine = g.state.isMine
    🔗
  • values = g.state.minesNearBy
    🔗

  🔗
  🔗
• Loop over the entire grid:

  • Update each zoneLabel so that it contains a number or a mine.
    🔗
  • Use the colors defined in g.settings.colors to set the number colors.
    🔗

  🔗
  🔗
• After calling this helper, all labels are fully initialized and will not change for the rest of the game. However, the player will not see them until the corresponding tile in g.gui.tiles is hidden by other helpers.
  🔗

Helpers Used.

Examples.

% Setup a minimal test environment:
rng(77,"twister");
g.settings = init_settings("easy");
g.state	= init_state(g.settings.gridSize);
[g.gui, fig] = init_gui(g.settings);

% Build a Mine layout and proximity numbers:
g.state.isMine = get_mines(g, 4, 5);
g.state.minesNearBy = get_mineCounts(g);

% Example: update labels, then delete tiles to reveal them all at once:
g = update_zoneLabels(g);
delete(g.gui.tiles) 	% ⚠️ This is a quick way to remove all  
						% tiles, do not do this in your assignment!

Description.

Signature.

Specifications.

• The task of this helper is to visually reveal the tiles that should become visible after a safe left-click and to update the revealed matrix to match what the player sees. Below are general hints for implementing this logic.
  🔗
• Begin by setting up a logical (true/false) matrix (with the same size as the grid) that flags the tiles have already been visited. This will be used to prevent adding the same location to the “exploration queue”.
  🔗
• \(\textbf{Exploration Queue}\text{.}\) We will store row & col locations in two column matrix. This list of locations will be called the explore_queue.
  🔗
• Each row of explore_queue is a pair [row col].
  🔗
• Place the location of the clicked tile in the queue and flag it as visited.
  🔗
• As long as the queue is not empty, we “process” the FRONT of the queue.
  🔗
• \(\textbf{Processing the queue}\text{.}\) Processing the queue involves the following steps:

  • Get the first row [r c] in the queue. This is our current location.
    🔗
  • Delete the first row (current location) from the queue.
    🔗
  • Reveal the tile (via the gui struct) at the current location if is neither flagged nor hiding a mine.
    🔗
  • If the current location has no nearby mines, then get its neighbors.
    🔗
  • \(\textbf{Add new neighbors to the queue}\text{.}\) For each neighbor that

    1. has not been visited,
       🔗
    2. is not flagged, and
       🔗
    3. does not have a mine,
       🔗

    add that neighbor to the queue and mark it as visited.

    🔗
    🔗
  • Continue “processing the queue” as long as it has locations.
    🔗

  🔗
  🔗
• Note: Only reveal the front of the queue (current location), not the neighbors. The neighbors will all get to the front of the queue eventually.
  🔗
• This search reveals an entire connected region of zeros and also reveals the nonzero tiles that border that region (since they are processed once but do not generate further neighbors).
  🔗
• This helper does not check win or loss conditions and does not start or stop the timer.
  🔗

Helpers Used.

Examples.

% After the first click at (r, c), and assuming the board is built
% and g.state.minesNearBy has been computed:

g = reveal_tiles(g, r, c);

% Now g.state.revealed marks all tiles that should be visible, and
% the corresponding rectangles in g.gui.tiles have been hidden so the
% underlying labels show through.

Description.

Signature.

Specifications.

• The task of this helper is to finalize the game visually and logically: stop the countdown clock and send a clear end-of-game message to the player via the GUI.
  🔗
• As its first action, this helper should stop the countdown timer by calling stop(g.clock). This prevents further time-limit checks after the game is over.
  🔗
• The rest of the behavior depends on whether the player won or lost.
  🔗
• After calling this helper, the game is visually and logically finished. The player should not be able to continue play; the only meaningful actions are to click the reset button (to start a new run) or to close the game window.
  🔗

Helpers Used.

Examples.

% Setup a minimal testing environment:
rng(77,"twister");
g.settings = init_settings("easy");
g.state	= init_state(g.settings.gridSize);
[g.gui, fig] = init_gui(g.settings);
g.clock   = init_clock(fig);

% Example 1: Player Won
g.state.playerWon = true;
g = game_over_screen(g, 2, 2);

% Example 2: Player Lost - Clicked on a Mine
g.state.playerWon = false;
g.state.timesUp   = false;
g = game_over_screen(g, 4, 5);

% Example 3: Time-out Loss & Explosion from center (Tier 3)
g.state.playerWon = false;
g.state.timesUp   = true;
g = game_over_screen(g, 1, 1);

Description.

Signature.

Specifications.

• The primary goal of this helper is to reinitialize both the state and visible gui back to their starting values without constructing a new figure window.
  🔗
• Begin by retrieving the current game structure.
  🔗
• The state structure can be reset by calling init_state.
  🔗
• Since the gui components already exist, don’t call init_gui. Instead, reset their properties in-place. Use a nested loop for the matrix components.
  🔗
• If your game includes a timer, be sure to stop the countdown clock and update the timeLabel to its initial value.\(^{🏆}\)
  🔗
• Since this is mouse-click event callback, you need to extract the current game state from the figure.
  🔗
• Before leaving, save the updated game structure back into the figure.
  🔗

Helpers Used.

Examples.

Description.

Signature.

Specifications.

• This helper is the central dispatcher for tile interactions. It is attached as the ButtonDownFcn callback for both tiles and flags so that every left or right click on the board passes through here.
  🔗
• The src variable contains the gui component that was clicked. This is used in this helper to get the \((x,y)\) location of the clicked space using

  • c = floor(src.Position(1)); - the column index.
    🔗
  • r = floor(src.Position(2)); - the row index.
    🔗

  This uniquely identifies the clicked space needed in this helper.

  🔗
  🔗
• The evt variable contains the information about the type of click. In particular, the value of its Button property is interpreted as follows:

  • A value of 1 means there was a left-click (reveal).
    🔗
  • A value of 3 means there was a right-click (flag).
    🔗
  • All other values are ignored.
    🔗

  🔗
  🔗
• The two main branches that determine game flow logic starts with determining whether the player made a left or right click. I will leave it up to you to write the code for each branch.
  🔗
• Here are a few hints:

  • g.state.gameStarted will be important in this helper.
    🔗
  • Ignore left-clicks on flagged cells.
    🔗
  • No flagging should be allowed before the first click.
    🔗

  🔗
  🔗

Helpers Used.

Examples.

Description.

Signature.

Specifications.

• The task of this helper is to generate a list of all grid points \((i,j)\) with \(i,j = 1,\dots,N\) and sort them from closest to farthest from the chosen center point \((\text{centerRow},\text{centerCol})\text{.}\)
  🔗
• Construct two arrays using loops:

  • An \(N^2 \times 2\) array points where each row is the grid point [i, j].
    🔗
  • An \(N^2 \times 1\) array dists where dists(k) is the squared distance between points(k,:) and [centerRow, centerCol].
    🔗

  🔗
  🔗
• To avoid unnecessary square roots, you may use squared Euclidean distance \((i - \text{centerRow})^2 + (j - \text{centerCol})^2\text{;}\) this preserves the ordering.
  🔗
• Use MATLAB’s built-in sort command to sort the distances and capture the corresponding index order: [~, idx] = sort(dists);.
  🔗
• Apply the sorted indices to the point list to obtain the radial ordering: gridList = points(idx,:);.
  🔗

Helpers Used.

Examples.

% Example 1: Small Grid
gridList = radially_sorted_grid(3, 1, 3)
% 
% Returns gridList =
% 
%	  1	 3
%	  1	 2
%	  2	 3
%	  2	 2
%	  1	 1
%	  3	 3
%	  2	 1
%	  3	 2
%	  3	 1

% Example 2: Big Grid 
gridList = radially_sorted_grid(30, 27, 19);
% 
% Check the output size
size(gridList)		% should be:	900	2
% Check a few rows
gridList(11,:)		% should be:	27	17
gridList(end,:)		% should be:	1	1

Description.

Signature.

Specifications.

• The task of this helper is to sequentially update tiles and labels in a radial order to simulate an explosion spreading out from the detonation tile.
  🔗
• Use configuration values from g.settings:

  • N = g.settings.gridSize — size of the board.
    🔗
  • icons = g.settings.icons — especially icons.explosion.
    🔗
  • delay = g.settings.explosionDelay — overall pace of the animation.
    🔗

  🔗
  🔗
• Play a sound effect at the start of the animation (e.g., landmine.mp3):

  • Use MATLAB’s audioread and sound commands, or another audio approach.
    🔗
  • Align the pauses in the animation with the audio using MATLAB’s pause(duration).
    🔗

  🔗
  🔗
• Obtain the radial ordering of tiles by calling your radially_sorted_grid helper. This returns an \(N^2 \times 2\) list of [r, c] pairs in the desired order.
  🔗
• Loop through each point in gridList and, for each (r,c):

  • Hide the tile and flag.
    🔗
  • If the location is not a mine, set the zoneLabel to your chosen explosion icon. otherwise, just leave the mine there.
    🔗

  🔗
  🔗
• To slow dow the animation, use MATLAB’s pause(duration) command within the animation loop.
  🔗
• No matter how small you set the pause duration, the animation will seem slow. To increase the speed add an if statement that only pauses every 10 loops. MATLAB’s mod command is a handy way to handle these skips.
  🔗
• When done, only explosion icons and mines should be seen on the board.
  🔗

Helpers Used.

Examples.

% Setup a minimal testing environment:
% Note: For testing, you may swap out any of the helpers below with the
% provided "key" versions.
rng(77,"twister");
g.settings = init_settings("easy");
g.state = init_state(g.settings.gridSize);
[g.gui, fig] = init_gui(g.settings);
g.state.isMine = get_mines(g, 4, 5);
g.state.minesNearBy = get_mineCounts(g);
g = update_zoneLabels(g);
guidata(fig, g);

% Example 1: Light the fuse...
g = explosion_animation(g, 7, 3);

Description.

Signature.

Specifications.

• The task of this helper is to construct a timer object that will drive the time-limit logic for the game without modifying any game state itself.
  🔗
• Configure the timer with:

  • clock.ExecutionMode = "fixedRate" so the callback runs at a constant frequency.
    🔗
  • clock.Period = 0.2 so check_time_limit is called 5 times per second.
    🔗
  • clock.TimerFcn = @(~,~) check_time_limit(fig) so each tick invokes your check_time_limit helper using the stored figure.
    🔗
  • clock.StopFcn = [] so the timer is not automatically deleted when stopped. This allows the same timer to be restarted on multiple runs.
    🔗

  🔗
  🔗
• The timer should not start automatically inside init_clock. It is initialized here, but it only begins running after the player’s first successful click, where clicked_on_tile calls start(g.clock).
  🔗
• When the game ends (win, loss, or time-out), other helpers such as game_over_screen should call stop(g.clock) to halt the countdown.
  🔗
• This helper does not inspect difficulty or time limits directly. Those values live in g.settings and are interpreted by check_time_limit, which uses the elapsed time and settings.timeLimit to update g.gui.timeLabel and possibly trigger a time-out loss.
  🔗

Helpers Used.

Examples.

% Minimal testing environment for the countdown clock.
rng(77,"twister");
g.settings = init_settings("test");
g.state = init_state(g.settings.gridSize);
[g.gui, fig] = init_gui(g.settings);
g.clock = init_clock(fig);
g.clock
% Returns something like:
% 	Timer Object: timer-7
% 
% 	Timer Settings
%		ExecutionMode: fixedRate
%			  Period: 0.2
%			BusyMode: drop
%			 Running: off
% 
% 	Callbacks
%		 	TimerFcn: @(~,~)check_time_limit(fig)
%		 	ErrorFcn: ''
%		 	StartFcn: ''
%		  	 StopFcn: []

Description.

Signature.

Specifications.

• Begin by retrieving the current game structure. If g.state.gameOver is already true, simply stop the clock and return.

  🔗
  🔗
• If the time limit is infinite (i.e. isinf(g.settings.timeLimit) == true), then there is no need to modify the timeLabel. Save g, and return.
  🔗
• Otherwise, compute how much time has elapsed and how much remains:

  • elapsed = toc(g.state.startTime) gives the elapsed time (seconds).
    🔗
  • Compute the remaining time based on this value.
    🔗
  • Update the timeLabel with the remaining time, but don’t allow it to display negative values.
    🔗

  🔗
  🔗
• If the time has run out, update the appropriate state values and trigger the game_over_screen
  🔗
• Remember to save the updated game structure back into the figure.
  🔗

Helpers Used.

Examples.

Description.

Signature.

Input Handling.

Specifications.

• minesweeper is the entry point and overall driver of the project. It can be broken down into the following steps (mostly handled by helpers):

  🔗
  1. Clean Up. Remove any artifacts from previous runs.
     🔗
  2. Initialize global settings in game.settings.
     🔗
  3. Initialize local data in game.state.
     🔗
  4. Initialize gui construction in game.gui.
     🔗
  5. Initialize timer construction in a clock structure.\(^{🏆}\)
     🔗
  6. Save the game structure.
     🔗
  7. Wait for mouse-click events (implicit game loop).
     🔗
  🔗
• In the clean up phase run:

  • clear game; removes existing game variables from the workspace.
    🔗
  • close all; closes all open figure windows.
    🔗

  🔗
  🔗
• Although the clock is initialized here, it does not start running until after the player’s first successful click (handled by clicked_on_tile).
  🔗
• Implicit game loop: Unlike Dice Poker, Minesweeper does not have an explicit “round-based” loop. Instead, gameplay continues through mouse-clicks that trigger the helper functions: clicked_on_tile, reset_game, or check_time_limit.
  🔗

Helpers Used.

Examples.

% Start a reproducible test game:
minesweeper("test", 42)

% Start a normal game:
minesweeper()

% Start an easy game:
minesweeper("easy")

% Start a game with undefined difficulty (defaults to "brutal"):
minesweeper("tutorial")

% After running one of these, interact with the GUI:
%   - Left-click to reveal tiles,
%   - Right-click to toggle flags,
%   - Click the reset icon to start a new run.