C-Programming Language Assignment

C PROGRAMMING LANGUAGE ASSIGNMENT
Student’s Name
C PROGRAMMING LANGUAGE ASSIGNMENT
Professor’s Name
City/State
Course
Date

Table of Contents
Introduction................................................................................................................................3
Project Requirements.................................................................................................................3
User Requirements.................................................................................................................3
System Requirements.............................................................................................................4
Problem Analysis.......................................................................................................................5
Project Specification..................................................................................................................6
Assumptions made.................................................................................................................7
Program Design..........................................................................................................................7
Project Implementation Report..................................................................................................8
Testing And Verification............................................................................................................9
User Manual.............................................................................................................................10

Introduction
Archery is the art of practicing and showing skills in shooting an arrow at a target
using a bow with precision. In history, archery was art used in hunting and combat, but its
currently practiced as a sport for competition and recreational activities. The game is played
by a single player who holds a bow and arrow, then aims at a target, which is usually located
some meters away and shooting the arrow at the target purposely to hit the center of the
circular target. The center of the target is a particular point called the bull’s eye, which is the
main focus point a player aims to hit. This point is surrounded by successive concentric
regions marked with colors. Hitting the bull’s eye earns a player the most marks. The closer
the region a player hits, the higher the marks scored in the game Applications Symposium
(RTAS) (pp. 227-239). Missing to hit the target leads to a score of no mark. One of the rules
for this game is that a player is given a maximum of ten arrows to use, and once all the ten
arrows have been shot, the total marks scored are calculated and the player is awarded points
(Applications Symposium (RTAS) (pp. 227-239). Players can compete this way, and the
player with the highest number of points emerges the winner. This project will focus on
developing a computer program in C programming language so to simulate the archery game.
Project Requirements
User Requirements
You are required to design and implement a computer game which is based on the
sport of archery. As the player, you control the force and elevation with which the arrow is
projected across a graphical landscape, aiming for the target, avoiding obstacles such as trees
and birds, and accounting for the effects of wind. The game must take into account the
following:
1. the flight of the arrow must be subject to the effect of gravity;
2. the number of arrows required to hit the target is used to calculate a score, taking

into account the difficulty of the shot (e.g., size of target and strength and
variability of wind);
3. if the arrow hits an obstacle or leaves the screen without landing it can be
considered to have missed the target;
4. the game should keep a score of play over ten targets of increasing difficulty;
5. incorporating sound into the game;
6. making use of the mouse to control the game;
The game must be enjoyable and playable for someone who is not experienced with
computers. The game experience should be rewarding and challenging. You might like to
think about:
1. adding levels of difficulty, such as including more obstacles, to make the game
increasingly challenging;
2. implementing a traditional bulls-eye archery target, with different scores for
hitting each concentric circle;
3. Ensuring that the game is not too frustrating to play — for example, give the
player unlimited arrows and make the targets easy to hit in the early stages of the
game.
Think about how to incorporate sound into your game. To achieve this, you can use
the functionality provided by the “amio” lib. In particular, you could use a callback design to
supply real-time audio to your application (e.g., sound of the ball being hit, cheers of the
crowd). Some good examples of how to achieve something like this can be found in the audio
example files; (audio01.c and other examples).

System Requirements
1. Running Platform-the system is required to run on Microsoft Windows operating
system
2. Development Platform- The programming language to be used in developing the
program is C. C programming is a general-use, procedural, imperative computer
programming language created in 1972 by Dennis M. to help in the development
of the UNIX OS. The C language is one of the most commonly used programming
languages. It keeps varying at first position in the scale of popularity along with
the Java programming language (Natarajan and Broman, 2018). Program
development for the archery game can be done on any other operating system
such as Mac OS and Linux, but the product must be fully compatible with MS
Windows.
3. Project IDE- Codeblocks will be used in the coding process since it supports most
C language libraries. Other IDEs such as Dev++, MS Visual Studio, and Netbeans
with the C/C++ plugin could still be used.
Problem Analysis
This project is tasked to design a 2-dimensional graphics program to simulate the
archery game. The game consists of a single player, who uses a bow to shoot arrows onto a
bull’s eye concentric target. In addition, the gameplay needs the integration of relevant
sounds to create realism. These sounds are to be produced when an arrow hits the target.
Different sounds are produced based on the regions of the target that were hit by the arrow.
The regions are concentric and can be marked with different colours for easy identification.
The game is made enjoyable by varying levels of difficulty. The difficulty levels are
determined by:
1. Distance between the bow and target. The bigger the distance, the higher the

difficulty
2. By making the target movable or immovable. The speed at which the target moves
will determine how difficult the game becomes. The higher speed of moving
target makes the game more challenging as focusing the arrow will be harder.
3. Also, by adding obstacles to the game scene will increase the level of difficulty.
The rules of the game require that objects should stop the game.
The rules of playing this game will require that a player is initially given ten arrows.
Only these ten arrows are used to determine the player’s score. The player scores more marks
when the arrow hits closer to the middle of the concentric target (Applications Symposium
(RTAS) (pp. 227-239). Missing the target leads to a score of no mark. Missing the target
includes instances where a shot arrow does not land on the target; that is, the arrow is blocked
by an obstacle, or it goes out of the screen without touching the target. The player is required
to control the elevation of the arrow and its speed of movement.
The arrow is affected by the laws of physics, such as gravity and resistance. This
implies that it will not move at a constant speed or straight direction. This will, therefore,
require the player to aim and determine the optimal angle, which would cause the arrow to hit
the center of the target.
Project Specification
The program will require the use of “Graphics.h” library developed in C language.
The graphics.h library is a free source tool used to enable the drawing of graphical objects in
C programming. It enables the development of C programs with a Graphical User Interface
(Natarajan, and Broman, 2018). This library has capabilities to create geometrical shapes and
add appropriate animations to them. This means that positions, colors and sizes of these
shapes are dynamic, thus making an animated user interface. The library is still under

development and more features are expected to be added in the future. This library will be
used to design the main objects required in gameplay. These objects include:
1. Bow- A bow is semi-circular in shape. The function of the bow is to shoot an
arrow. The bow is static and does not move during gameplay. The bow is
positioned at the right side of the screen.
2. Arrow- This is a straight horizontal line with a pointer on the left side. The arrow
moves from right to left. The speed of movement varies with the player. The
arrow can also be elevated at an angle. When the game is initialized, ten objects of
arrows are created.
3. Target- the target is a two-dimensional circle with concentric regions that progress
from the centre. These regions are marked with different colours to enable
visibility. The purpose of these regions is to determine the score of the player
during gameplay. There would be five regions whereby the innermost region is
coloured red. This is referred to as the bull’s eye. Hitting this region will lead to a
maximum score of 50 points. As the regions move outwards, the points of the
score are reduced by 10points. That is, the order of score from bull’s eye to outer
region is 50,40,30,20, and finally 10. The target can be static or movable,
depending on game difficulty. The position of the target is left of the screen, but
the margin from left varies with game difficulty. In addition, the game requires the
saving of player data. The data is stored in a text file, where the scores and
progress of the game are tracked.
Assumptions made
In developing this project, some things were assumed in playing the game contrary to
the real archery sport. First, in real life, the target is made of a soft rubber-like material,
which when an arrow is shot, it hits and sticks. However, in developing this game, it was

assumed that once an arrow has hit the target, it is removed after noting the point of contact
and score of the player. Therefore, arrows hitting the target will not accumulatively stick on
it. Also, arrows that miss the target go beyond the visible screen and their final positions are
not accounted for. It is also assumed that arrows in real life are of equal weight and length.
Another assumption made is that there is no time limit given for a player to aim at a target
before shooting. Therefore, players can take their maximum time to aim before releasing an
arrow.
Program Design
The player uses a mouse to click on commands and play the game. The program has
three main displays. These displays are as described as follows.
1. The Welcome Screen
This screen is displayed when the game is being initialized on startup. It displays the
title of the program at the top center, followed by instructions and rules applied in playing the
game, and finally a button to go to the next screen. The layout of the screen is as shown in the
figure below:
Figure 1.0.1 Welcome Screen
2. Gameplay screen
Game Title
Instructions and rules on how to play the game
…
…
Start Playing >>

The gameplay screen displays the main scenery of game. It positions the arrow, bow,
and target at their respective positions, as shown in the figure below. In addition, it shows
text displaying the status of the game, that is, the score and the number of arrows remaining.
Figure 1.2 Gameplay Screen
3. Game-over screen
This screen is displayed when the player has shot all the arrows, and no arrow is
remaining. The screen notifies that the game is over and displays the score of the player.
Additionally, it gives the player the option of replaying the game or quitting the game. The
layout is as described in the figure below.
Figure 1.3 Game Over Screen
You scored 215 points
Game Over!
Replay Quit
Score: 0
Arrows Remaining: 9

Project Implementation Report
Running the game gives an enjoyable experience. The program enabled the use of a
mouse to play the game. The User herein referred to as “Player,” clicks on objects of the
screen window to execute game commands. The program flow runs smoothly. No crashes or
bugs have been reported to the current development stage of the program. Simpler sounds
were used for notifications to make the game more lively. The game keeps track of player
progress, and the highest scores are stored in a text file. The program initializes by opening
the data file and reading the stored highscores and other configuration settings. If this file
does not exist, the program creates one, and default settings are loaded to the game.
The levels of difficulty are divided into three distinct types, which include easy level,
standard level and hard level. The easy level places the target and bow at a close distance,
and also, the target is immovable. The player has to complete preliminary stages before
accessing advanced stages (Natarajan, and Broman, 2018). Meaning, the hard level is locked
until the standard level is completed, which is consequently unlocked only when the easy
level has been completed. To complete a level, the player is required to hit the bull's eye
using atleast seven arrows. This could mean that the player has only three chances to miss the
target. However, the game can be set to be in two-player mode, where two physical users
operate the program as players. In this mode, the difficulty level of the game can be set to any
mode.
The project, however, did not include the implementation of some physics laws such
as gravity, as defined in the specification requirements. This was due to problems
encountered in the library intended to be used. The graphics library is still under development
and attempts to use its setGravity() method did not give expected results and was thus
discarded in the meantime. No other library was at reach to substitute. Additionally, the
project did not meet the requirement of adding obstacles such as trees and birds in the

gameplay scene. This is because the game was already at a reasonably difficult level, and
adding such constraints could lead the game to become too challenging to play.
Testing And Verification
Functional testing was used to verify the program. Six different users had experience
in playing the game three times each, and their scores were noted down anonymously. This
was used to determine whether the game was playable and whether it was interesting. Each
player rated the game on a scale of 1 to 5 stars. The results were noted, as shown in the table
below.
User Name 1st Game 2nd Game 3rd Game User rating
Player 1 170 310 290 1
Player 2 120 280 370 5
Player 3 140 290 320 3
Player 4 250 340 470 5
Player 5 220 310 310 3
Player 6 210 90 340 4
Average 185 270 350 3.5
Table 1.1 User Testing and Feeback Report
The report showed that the game progressively became familiar to the players as they
continued playing. However, still, none of the players was able to shoot all the arrows onto
the bull’s eye. In addition, not all players were able to increase their scores, for instance,
player 1 scored 170 in the first game, improved to 310 in the second game but in the third
game, the player scored 290, which is a drop. This implied that the game was challenging and
exciting. Also, the average score of the game was 3.5. This was reasonably good given that
the game was not developed in 3-D graphics, in this era of the digital world.
Users did not have any functionality issue instances of breakdown. This showed that
the program was valid and verifiable. Considering that tests during program coding were
successful, the process of program verification and testing can be concluded to be successful.

User Manual
The archery game program has some rules modified and therefore, may not be as set
in real life archery sport. Make sure that your computer is well configured to play audios so
that the gameplay produces sounds as required (Natarajan, and Broman, 2018). Ensure to
unmute speakers and increase the volume level to hear sounds. The program is not yet
developed to support game pads to play. Be aware that you will only interact with the
program using mouse and keyboard only. This guide shows you how to use the program.
Please read and follow these instructions carefully. Explore more with care.
1. Click on the main.c file and build it using the GNU GCC compiler. Ensure the
header file “Graphics.h” is appropriately configured.
2. This will produce an executable file “ ArcheryGame.exe” in the build folder of
your project location.
3. Run the executable file and give administrator rights when required. Note that the
program is developed to be compatible with the Microsoft Windows operating
system only. In case you use a different platform, consider running doing this
operation in a virtual box well configured to emulate the windows platform.
4. The program’s welcome screen will be displayed. The player is required to read
the game instructions and be acquitted with the rules of the game set in the
program before he/she starts to play. To begin playing, click on the “Start
playing>>” button located at the bottom of the display window.
5. This will open the gameplay screen. The game screen will generally have a target
at the left side, and a bow to the right side. An arrow will, by default, be attached
to the bow. The user is required to click on the region around the bow to shoot an
arrow. The user is required to roll the mouse wheel either up to elevate the arrow
upwards or down to elevate the arrow downwards.

6. Shoot until you run out of all the ten arrows given. Ensure to aim at the bull’s eye
to score maximum points.
7. Once all arrows are shot, your game will be over, and the ‘Game Over’ screen will
be displayed showing score of the player and options of whether to continue
playing the game or exit the program. Click on the appropriate button as per your
wish. Clicking on the “Quit Game” button will close the program and exit the
game. Enjoy the game.

List of References
Beuken, B., 2018. The Fundamentals of C/C++ Game Programming: Using Target-based
Development on SBC's. AK Peters/CRC Press.
Natarajan, S., and Broman, D., 2018, April. Timed c: An extension to the c programming
language for real-time systems. In 2018 IEEE Real-Time and Embedded Technology
and Applications Symposium (RTAS) (pp. 227-239). IEEE.