Webpage Design Structure Analysis

Webpage Design
APPLIED ENGINEERING STATISTICS
Research Proposal
Student Name –
Student ID –

Introduction :
The game development has become a very interesting application of the softwares like
Matlab. The software Matlab can be used to design several games. The game chosen here is
Battleship. It is a board game. It is based on development of a strategy by using guesses. It
can be played by 2 players or can be 1 player if the other player is considered to be the
computer or software. The game can also be designed for 2 players using the UDP
communication. This needs the use of MATLAB along with the Instrument Control Toolbox.
It consists of a ruled grid on the board. A fleet of ships along with the battleships are marked
on the board for each player. The other player is not shown the fleet locations of a player.
Every player gets a chance alternately. The aim of the game is the destruction of the fleet of
the opposite player. This game can be efficiently designed using Matlab.
Objectives :
The goal is to develop a game using Matlab. The game chosen here is Battleship, which is a
board game. Matlab has several features for game designing. The aim of this project is to
explore and learn these amazing features present in Matlab for game deigning and GUI
( Graphical User Interface ). When the game is designed from scratch, a lot of things are
learnt with time. Here, the game has to be designed using a Matlab code which is efficient.
Flowchart :
The Figure 1 shows the flowchart which can be used while designing the Battleship game.

Figure 1
The first phase in the design is the initialization phase. The player starts by initialising his
grid and his own view of the opponent’s grid. Then, these grids are saved. In the grid, an
entry ‘0’ means it is empty and an entry ‘1’ shows that the block is occupied by a ship.
Similar procedure is carried out by the opponent. Then, each player’s turn comes one by one.
The flowchart depicts the series of events which take place when a player’s turn comes. The
player loads the opponent’s grid first and then he fires a salvo ( i.e. , he requests the
coordinates ). The actual opponent’s grid is updated with a ‘0’. The opponent’s grid is then
saved. Now, the player loads his own grid. If it is a ‘hit’, then the player updates his copy of
opponent’s grid with a ‘1’ and saves his grids and again loads the opponent’s grid and the
process goes on. If it was not a hit, then the player updates his copy of the opponent’s grid
with a ‘0’ and saves his grids. After this, it is the opponent’s turn. In this manner the game
goes on. In case of a ‘hit’, the same player continues his moves and in case of ‘not a hit’, the
other player gets a chance to play his move.

This defines the manner in which the game proceeds. Apart from this a game must be user
friendly. For this to occur, appropriate messages need to be displayed at correct time and the
graphics need to be good and well placed. The winner is the player who gets all the ships of
his opponent sunk. A draw can also occur if both the players’ ship get sunk.
Background :
Battleship is a board game which is based on developing a strategy using guesses. It can be
played by 2 players. It consists of a ruled grid (on a board). The fleet of ships along with the
battleships are marked on this for each player. The other player is not shown the fleet’s
locations. Each player gets a chance alternately. The goal of the game is the destruction of the
fleet of the opposite player. Both the chance as well as strategy helps to win the game. The
game can be designed using MATLAB software. The goal is to sink the battleships of the
computer in the minimum number of moves possible. The GUI version can be designed for a
single player. The goal here is to sink all the ships ( 5 here ) in minimum possible number of
moves.
The game can also be designed for 2 players using the UDP communication. This will require
the use of MATLAB along with the Instrument Control Toolbox.
The game consists of 4 grids. Each player has 2 grids. The grid is square in shape ( generally
10 x 10 ). To identify the squares individually, letters and numbers are used. One of the grids
is used by the player to arrange the ships and to record the opponent’s shots. The second grid
is used by the player to record his own shots. Both the players arrange the ships on the
primary grid before the game starts. Every ship requires a certain number of continuously

arranged squares on the grid, in a horizontal or vertical manner. The number of squares used
by a ship depends on its type.
There can be no overlapping between the ships. For example : Aircraft carrier ( 5 squares /
blocks ), Battleship (4 squares / blocks), Destroyer ( 2 squares / blocks), Submarine ( 3
squares / blocks) and Cruiser ( 3 squares / blocks).
When the ships are placed initially, the game then starts and several rounds take place. In
every round, the player selects a target square ( in the grid of the opponent ) to be shot. The
opponent tells if the square is occupied by a ship or not. In case of “hit”, the player marks it
on his own grid. Once all squares of a ship are hit, the ship gets sunk. If all the ships of a
player sink, then the game is over and the other person wins.
Methodology :
Initially, a rough draft of the design will be prepared. The requirements of the game are
studied in detail. The various inputs and outputs are identified. As the game needs to have a
GUI ( Graphic User Interface ), the design needs to be finalised. The various shots and the
conditions to be imposed need to be decided. The various available Matlab commands and
features will then be studied to design a code which is efficient. The complete game can be
broken into various parts or modules. These parts can be designed individually and then all
the parts can be combined to give the complete system.
First, the code for various parts will be written one by one and tested on the software Matlab.
When are sub – parts work successfully, then all of them will be combined to give the
complete code. When this code is run, the game board must be displayed on which the user
can play the game successfully. There must be appropriate messages displayed when the user
is playing the game to direct him in the right direction.

References :
Altamirano, N., Radhakrishnan, B., & Jaurez, J. J. (2016). Facilitating Game Design in the
Online Classroom: Building Efficiencies in Teaching while Students Build Games for
Learning. In Increasing Productivity and Efficiency in Online Teaching (pp. 216-243). IGI
Global.
Alvare, G., & Gordon, R. (2015). CT brush and CancerZap!: two video games for computed
tomography dose minimization. Theoretical Biology and Medical Modelling, 12(1), 7.
Cauwet, M. L., & Teytaud, O. (2018, July). Surprising strategies obtained by stochastic
optimization in partially observable games. In 2018 IEEE Congress on Evolutionary
Computation (CEC) (pp. 1-8). IEEE.
Craven, P. V. (2016). Array-Backed Grids. In Program Arcade Games (pp. 287-300). Apress,
Berkeley, CA.
Fürst, L., & Mahnic, V. (2013). Introductory programming course: motivating students with
prior knowledge. World transactions on engineering and technology education, 11(4), 400-
405.
Ossman, K., & Bucks, G. (2013). First year student team projects using matlab.
In Proceedings of the 5th First Year Engineering Experience (FYEE) Conference.
Riegel, M. J. (2012). Nontraditional Positional Games: New methods and boards for playing
Tic-Tac-Toe.
Villegas, J., Wilson, I., & Perkins, J. (2015). Effect of task on the intensity of speech in noisy
conditions. Dialog, 61, 66-7.