‭A PROJECT REPORT‬

‭submitted to‬

‭COCHIN UNIVERSITY OF SCIENCE & TECHNOLOGY‬

‭by‬

‭ dnan Kuthradan (20420005)‬

A
‭Amarantha Soniya Sherry (20420016)‬
‭Fimil Faneea (20420040)‬
‭Hisham V P (20420045)‬
‭Jeremy Varughese (20420048)‬

i‭n partial fulfilment for the award of the degree‬

‭of‬ ‭BACHELOR OF TECHNOLOGY‬
‭in‬
‭INFORMATION TECHNOLOGY‬

‭DIVISION OF INFORMATION TECHNOLOGY‬

‭SCHOOL OF ENGINEERING‬
‭COCHIN UNIVERSITY OF SCIENCE & TECHNOLOGY‬

‭KOCHI- 682 022‬

‭KERALA | INDIA‬
 ‭ACKNOWLEDGEMENT‬

‭ e‬ ‭are‬ ‭pleased‬ ‭to‬ ‭present‬ ‭the‬ ‭"Golf"‬ ‭game‬ ‭and‬ ‭take‬ ‭this‬‭opportunity‬‭to‬
W
‭express‬ ‭our‬ ‭profound‬ ‭gratitude‬ ‭to‬ ‭all‬ ‭those‬ ‭people‬ ‭who‬‭helped‬‭us‬‭in‬‭the‬
‭completion‬ ‭of‬ ‭this‬ ‭game.‬ ‭We‬ ‭are‬ ‭thankful‬ ‭to‬ ‭The‬ ‭Head‬ ‭of‬ ‭Department,‬
‭Information‬‭Technology,‬‭Dr.‬‭Daleesha‬‭M‬‭Vishwanathan,‬‭for‬‭giving‬‭us‬‭all‬
‭the‬ ‭support.‬ ‭We‬ ‭express‬ ‭our‬ ‭sincere‬ ‭thanks‬ ‭to‬ ‭our‬ ‭Game‬ ‭Coordinator,‬
‭xxxx,‬‭for‬‭giving‬‭us‬‭proper‬‭support,‬‭innovative‬‭suggestions,‬‭timely‬‭advice,‬
‭and‬‭suggestions‬‭during‬‭this‬‭endeavour.‬‭Last,‬‭but‬‭not‬‭least,‬‭we‬‭express‬‭our‬
‭gratitude‬‭to‬‭all‬‭the‬‭class‬‭coordinator,‬‭Dr.‬‭Shelbi‬‭Thomas,‬‭and‬‭game‬‭guide‬
‭xxxx‬‭for‬‭their‬‭valuable‬‭advice‬‭and‬‭timely‬‭suggestions.‬‭We‬‭would‬‭also‬‭like‬
‭to‬ ‭thank‬ ‭the‬ ‭faculties‬ ‭of‬ ‭School‬ ‭of‬ ‭Engineering,‬ ‭CUSAT‬ ‭for‬ ‭their‬
‭encouragement.‬

‭ dnan Kuthradan‬
A
‭Amarantha Soniya Sherry‬
‭Fimil Faneea‬
‭Hisham V P‬
‭Jeremy Varughese‬

‭2‬
 ‭DIVISION OF INFORMATION TECHNOLOGY‬

‭ CHOOL OF ENGINEERING‬
S
‭ OCHIN UNIVERSITY OF SCIENCE & TECHNOLOGY‬
C

‭CERTIFICATE‬

‭ his‬ ‭is‬ ‭to‬ ‭certify‬ ‭that‬ ‭the‬ ‭project‬ ‭report‬ ‭entitled‬ ‭"GOLF"‬
T
‭submitted‬ ‭by‬ ‭Fimil‬ ‭Faneea,‬ ‭Amarantha‬ ‭Soniya‬ ‭Sherry,‬
‭Adnan‬ ‭Kuthradan,‬ ‭Jeremy‬ ‭Varughese,‬ ‭Hisham‬ ‭VP‬ ‭to‬ ‭the‬
‭Cochin‬‭University‬‭of‬‭Science‬‭&‬‭Technology,‬‭Kochi,‬‭Kerala,‬‭in‬
‭partial‬ ‭fulfilment‬ ‭for‬ ‭the‬ ‭award‬ ‭of‬ ‭the‬ ‭Degree‬ ‭of‬ ‭Bachelor‬ ‭of‬
‭Technology‬‭in‬‭Information‬‭Technology‬‭is‬‭a‬‭bonafide‬‭record‬‭of‬
‭the‬ ‭project‬ ‭work‬ ‭carried‬ ‭out‬ ‭by‬ ‭them‬ ‭under‬ ‭my‬ ‭supervision‬
‭during March 2023 - July 2023.‬

‭ r. Daleesha M Viswanathan‬
D ‭Dr. Shelbi Thomas‬
‭Head‬
‭Division Of Information Technology‬ ‭Project Guide‬

‭3‬
 ‭ABSTRACT‬

‭ olf,‬ ‭a‬ ‭captivating‬ ‭Unity-based‬ ‭game,‬ ‭invites‬ ‭players‬ ‭to‬

G
‭embark‬ ‭on‬ ‭a‬ ‭journey‬ ‭through‬ ‭five‬ ‭levels‬ ‭of‬ ‭escalating‬
‭challenges,‬ ‭each‬ ‭level‬ ‭introducing‬ ‭a‬ ‭new‬ ‭layer‬ ‭of‬ ‭difficulty.‬
‭With‬ ‭a‬ ‭maximum‬ ‭of‬ ‭eight‬ ‭shots‬ ‭per‬ ‭level,‬ ‭players‬ ‭must‬
‭skillfully‬ ‭navigate‬ ‭the‬ ‭virtual‬‭course,‬‭combining‬‭precision‬‭and‬
‭strategy‬ ‭to‬ ‭achieve‬ ‭success.‬ ‭The‬ ‭game‬ ‭offers‬ ‭an‬ ‭immersive‬
‭experience,‬ ‭where‬ ‭the‬ ‭lush‬ ‭virtual‬ ‭landscapes‬ ‭and‬ ‭intricately‬
‭designed‬ ‭courses‬ ‭create‬ ‭an‬ ‭engaging‬ ‭backdrop‬ ‭for‬ ‭players‬ ‭to‬
‭hone‬‭their‬‭skills.‬‭Whether‬‭you're‬‭a‬‭novice‬‭or‬‭a‬‭seasoned‬‭player,‬
‭Golf‬ ‭promises‬ ‭an‬ ‭entertaining‬ ‭and‬ ‭rewarding‬ ‭gameplay‬
‭experience.‬ ‭The‬ ‭intuitive‬ ‭controls‬ ‭and‬ ‭dynamic‬ ‭level‬
‭progression‬ ‭make‬ ‭this‬ ‭Unity-based‬ ‭game‬ ‭a‬ ‭delightful‬ ‭choice‬
‭for‬‭those‬‭seeking‬‭both‬‭casual‬‭enjoyment‬‭and‬‭competitive‬‭thrills‬
‭in the world of virtual golf.‬

‭4‬
‭Title‬ ‭Page‬

‭ACKNOWLEDGEMENT‬ ‭2‬
‭ABSTRACT‬ ‭4‬

‭CHAPTER 1 INTRODUCTION‬

‭1.1‬ ‭Problem statement‬ ‭7‬

‭1.2‬ ‭Objectives‬ ‭8‬

‭1.3‬ ‭ dvantages and disadvantages‬

A ‭9‬
‭1.3.1. Advantages‬
‭1.3.2. Disadvantages‬

‭CHAPTER 2 REQUIREMENTS‬

‭2.1‬ ‭Functional requirements‬ ‭12‬

‭2.2‬ ‭Non-functional requirements‬ ‭13‬

‭CHAPTER 3 DESIGN‬ ‭14‬

‭CHAPTER 4 IMPLEMENTATION AND TESTING‬ ‭17‬

‭CHAPTER 5 RESULTS AND DISCUSSIONS‬ ‭37‬

‭CHAPTER 6 CONCLUSION AND FUTURE SCOPE‬ ‭41‬

‭REFERENCE‬ ‭43‬

‭5‬
 ‭CHAPTER 1‬

‭INTRODUCTION‬

‭ his‬ ‭project‬ ‭report‬ ‭unveils‬ ‭"Golf,"‬ ‭a‬ ‭Unity-based‬ ‭game‬ ‭that‬

T
‭transforms‬ ‭the‬ ‭gaming‬ ‭experience‬ ‭by‬ ‭offering‬ ‭an‬ ‭engaging‬ ‭and‬
‭dynamic‬‭journey‬‭through‬‭various‬‭levels.‬‭Departing‬‭from‬‭traditional‬
‭gaming‬ ‭norms,‬ ‭Golf‬ ‭removes‬ ‭the‬ ‭need‬ ‭for‬ ‭complex‬ ‭controls,‬
‭providing‬ ‭an‬ ‭intuitive‬ ‭and‬ ‭accessible‬ ‭interface‬ ‭for‬ ‭players.‬ ‭The‬
‭game‬ ‭unfolds‬ ‭across‬ ‭five‬ ‭progressively‬ ‭challenging‬ ‭levels,‬ ‭with‬
‭each‬ ‭stage‬ ‭presenting‬ ‭a‬ ‭heightened‬ ‭level‬ ‭of‬ ‭difficulty.‬ ‭Players‬ ‭are‬
‭allowed‬ ‭a‬ ‭maximum‬ ‭of‬ ‭eight‬ ‭shots‬ ‭per‬ ‭level,‬ ‭demanding‬ ‭strategic‬
‭thinking‬ ‭and‬ ‭precision.‬ ‭Beyond‬ ‭the‬ ‭captivating‬ ‭gameplay,‬ ‭Golf‬
‭emphasizes‬‭a‬‭visually‬‭immersive‬‭experience,‬‭showcasing‬‭intricately‬
‭designed‬ ‭virtual‬ ‭landscapes.‬ ‭With‬ ‭its‬ ‭user-friendly‬ ‭controls‬ ‭and‬
‭escalating‬ ‭challenges,‬ ‭Golf‬ ‭is‬ ‭poised‬ ‭to‬‭deliver‬‭an‬‭entertaining‬‭and‬
‭skill-testing‬ ‭alternative,‬ ‭catering‬ ‭to‬ ‭both‬ ‭casual‬ ‭players‬ ‭and‬ ‭those‬
‭seeking a competitive edge in virtual sports gaming.‬

‭6‬
‭1.1 PROBLEM STATEMENT‬

I‭ n‬ ‭the‬ ‭current‬ ‭landscape‬ ‭of‬ ‭golf‬ ‭games,‬ ‭players‬ ‭often‬ ‭face‬

‭challenges‬ ‭that‬ ‭impact‬ ‭their‬ ‭gaming‬ ‭experience.‬ ‭Traditional‬
‭approaches‬ ‭involve‬ ‭complex‬ ‭control‬ ‭mechanisms,‬‭creating‬‭barriers‬
‭for‬ ‭players‬ ‭seeking‬ ‭an‬ ‭intuitive‬ ‭and‬ ‭accessible‬ ‭gaming‬ ‭interface.‬
‭Players‬ ‭may‬ ‭find‬ ‭it‬ ‭difficult‬ ‭to‬ ‭navigate‬ ‭through‬ ‭different‬ ‭game‬
‭levels‬ ‭seamlessly,‬ ‭hindering‬ ‭the‬ ‭overall‬ ‭enjoyment‬ ‭of‬ ‭the‬ ‭gaming‬
‭experience.‬

‭ oreover,‬ ‭existing‬ ‭golf‬ ‭games‬ ‭lack‬ ‭a‬ ‭balance‬ ‭between‬ ‭engaging‬

M
‭gameplay‬ ‭and‬ ‭user-friendly‬ ‭controls.‬ ‭The‬ ‭need‬ ‭for‬ ‭precise‬ ‭shot‬
‭execution‬‭often‬‭results‬‭in‬‭a‬‭steep‬‭learning‬‭curve‬‭for‬‭players,‬‭limiting‬
‭the‬ ‭game's‬‭accessibility‬‭to‬‭a‬‭broader‬‭audience.‬‭This‬‭complexity‬‭not‬
‭only‬ ‭discourages‬ ‭new‬ ‭players‬ ‭but‬ ‭also‬ ‭hampers‬ ‭the‬ ‭potential‬ ‭for‬ ‭a‬
‭more inclusive gaming community.‬

‭ ddressing‬ ‭these‬ ‭issues‬ ‭is‬ ‭crucial‬ ‭to‬ ‭enhancing‬ ‭the‬ ‭appeal‬ ‭and‬
A
‭accessibility‬ ‭of‬ ‭golf‬ ‭games,‬ ‭ensuring‬ ‭a‬ ‭more‬ ‭enjoyable‬ ‭experience‬
‭for‬‭players‬‭of‬‭all‬‭skill‬‭levels.‬‭The‬‭goal‬‭is‬‭to‬‭revolutionise‬‭the‬‭gaming‬
‭landscape‬ ‭by‬ ‭introducing‬ ‭an‬ ‭innovative‬ ‭approach‬ ‭that‬ ‭prioritises‬
‭user-friendly‬ ‭controls‬ ‭and‬ ‭an‬ ‭immersive,‬ ‭yet‬ ‭accessible,‬ ‭gameplay‬
‭experience.‬

‭7‬
‭1.2 OBJECTIVES‬

‭ he primary goals of the "Golf" project are centered around‬

T
‭developing a Unity-based game that redefines the golf gaming‬
‭experience. This involves creating an accessible and engaging‬
‭gameplay interface, departing from traditional complexities. The‬
‭project focuses on providing an intuitive control system, ensuring‬
‭players can effortlessly navigate through five challenging levels.‬

‭ he game aims to establish a user-friendly environment where‬

T
‭players can enjoy a dynamic gaming experience without the need‬
‭for intricate shot execution. The project emphasizes inclusivity,‬
‭intending to cater to both novice and seasoned players.‬
‭Additionally, the implementation of a maximum of eight shots per‬
‭level adds an element of strategy, enhancing the overall gaming‬
‭challenge.‬

‭ urthermore, continuous testing and refinement, guided by user‬

F
‭feedback, will be integral to ensuring the "Golf" game offers a‬
‭reliable and enjoyable experience for players across varying skill‬
‭levels. The project aims to contribute to the evolution of golf‬
‭gaming, delivering an accessible and entertaining alternative in the‬
‭virtual sports landscape.‬

‭8‬
‭1.3 ADVANTAGES AND DISADVANTAGES‬

‭1.3.1‬‭ADVANTAGES‬

‭The advantages of the “Golf” game are as follows:‬

‭●‬ E
‭ ffortless‬ ‭Gameplay:‬ ‭The‬ ‭"Golf"‬ ‭game‬ ‭provides‬ ‭players‬
‭with‬‭an‬‭effortless‬‭gaming‬‭experience‬‭by‬‭offering‬‭an‬‭intuitive‬
‭control‬ ‭system.‬ ‭Players‬ ‭can‬ ‭navigate‬ ‭through‬ ‭the‬ ‭game‬
‭seamlessly,‬ ‭eliminating‬ ‭complexities‬ ‭and‬ ‭enhancing‬ ‭overall‬
‭enjoyment.‬

‭●‬ A
‭ ccessible‬ ‭User‬ ‭Interface:‬ ‭The‬ ‭project‬ ‭is‬ ‭committed‬ ‭to‬
‭creating‬ ‭an‬ ‭accessible‬ ‭user‬ ‭interface‬ ‭that‬ ‭simplifies‬ ‭the‬ ‭golf‬
‭gaming‬ ‭process.‬ ‭The‬ ‭game's‬ ‭design‬ ‭prioritizes‬
‭user-friendliness,‬ ‭ensuring‬ ‭smooth‬ ‭navigation‬ ‭and‬ ‭a‬
‭hassle-free experience for players of varying skill levels.‬

‭●‬ S
‭ ecure‬ ‭Gaming‬ ‭Environment‬‭:‬ ‭With‬ ‭a‬ ‭focus‬ ‭on‬ ‭secure‬
‭gaming,‬ ‭"Golf"‬ ‭integrates‬ ‭reliable‬ ‭measures‬ ‭to‬ ‭safeguard‬
‭player‬ ‭data‬ ‭and‬ ‭ensure‬ ‭a‬ ‭secure‬ ‭gaming‬ ‭environment.‬ ‭This‬
‭includes‬ ‭secure‬ ‭handling‬ ‭of‬ ‭in-game‬ ‭transactions,‬ ‭fostering‬
‭player confidence.‬

‭●‬ T
‭ ime-Optimised‬ ‭Gameplay:‬ ‭"Golf"‬ ‭optimises‬ ‭the‬ ‭gaming‬
‭experience‬ ‭by‬ ‭providing‬ ‭players‬ ‭with‬ ‭a‬ ‭set‬ ‭number‬‭of‬‭shots‬
‭per‬ ‭level,‬ ‭promoting‬ ‭strategic‬ ‭decision-making‬ ‭and‬‭efficient‬
‭gameplay.‬ ‭This‬ ‭design‬ ‭minimises‬ ‭time‬ ‭spent‬ ‭on‬ ‭each‬ ‭level,‬
‭enhancing the overall gaming flow.‬

‭9‬
‭●‬ E
‭ ngagement‬ ‭without‬ ‭Environmental‬ ‭Impact:‬ ‭The‬ ‭project‬
‭aligns‬ ‭with‬ ‭eco-conscious‬ ‭principles‬ ‭by‬ ‭reducing‬ ‭the‬
‭environmental‬ ‭impact‬ ‭associated‬ ‭with‬ ‭traditional‬ ‭gaming‬
‭methods.‬‭"Golf"‬‭eliminates‬‭the‬‭need‬‭for‬‭physical‬‭accessories‬
‭or‬ ‭excessive‬ ‭resource‬ ‭consumption,‬ ‭contributing‬ ‭to‬ ‭a‬
‭sustainable gaming environment.‬

‭●‬ I‭ terative‬ ‭Enhancement:‬ ‭Embracing‬ ‭a‬ ‭player-centric‬

‭approach,‬ ‭the‬ ‭project‬ ‭incorporates‬ ‭continuous‬ ‭testing‬ ‭and‬
‭actively‬ ‭seeks‬ ‭player‬ ‭feedback‬ ‭for‬ ‭ongoing‬ ‭improvements.‬
‭This‬ ‭iterative‬ ‭process‬ ‭ensures‬ ‭a‬ ‭dependable,‬ ‭enjoyable,‬ ‭and‬
‭accessible gaming experience with the "Golf" application.‬

‭1.3.2 DISADVANTAGES‬

‭●‬ T
‭ echnology‬‭Dependency:‬‭The‬‭"Golf"‬‭game‬‭relies‬‭on‬‭mobile‬
‭devices,‬ ‭internet‬ ‭connectivity,‬ ‭and‬ ‭digital‬ ‭payment‬ ‭systems,‬
‭making‬ ‭it‬ ‭vulnerable‬ ‭to‬ ‭disruptions‬ ‭caused‬ ‭by‬ ‭technical‬
‭issues.‬

‭●‬ U
‭ ser‬ ‭Adoption‬ ‭and‬ ‭Familiarity:‬ ‭Users‬ ‭who‬ ‭are‬ ‭less‬
‭tech-savvy‬ ‭or‬ ‭unfamiliar‬ ‭with‬ ‭mobile‬ ‭apps‬ ‭may‬ ‭struggle‬ ‭to‬
‭adopt‬ ‭and‬ ‭use‬ ‭the‬ ‭game,‬ ‭leading‬ ‭to‬ ‭a‬ ‭learning‬ ‭curve‬ ‭and‬
‭potential resistance to change.‬

‭10‬
‭●‬ D
‭ evice‬ ‭Compatibility:‬ ‭Compatibility‬ ‭issues‬ ‭may‬ ‭arise‬‭with‬
‭older‬ ‭devices‬‭or‬‭operating‬‭systems,‬‭limiting‬‭access‬‭for‬‭users‬
‭with outdated or incompatible devices.‬

‭●‬ L
‭ imited‬ ‭Availability‬ ‭and‬ ‭Accessibility:‬ ‭The‬ ‭game's‬
‭usefulness‬ ‭may‬ ‭be‬ ‭restricted‬ ‭to‬ ‭specific‬ ‭platforms‬ ‭or‬
‭locations,‬ ‭while‬ ‭individuals‬ ‭without‬ ‭smartphones‬‭or‬‭reliable‬
‭internet access may face difficulties in utilising its features.‬

‭11‬
 ‭CHAPTER 2‬
‭REQUIREMENTS‬

‭2.1‬ ‭FUNCTIONAL REQUIREMENTS‬

‭2.1.1.‬ ‭Main Menu Screen‬

‭Here, we can see all the levels of the game‬

‭2.1.2.‬‭Diverse Courses:‬

I‭ nclude a variety of creative and challenging mini golf courses with‬

‭different themes, obstacles, and landscapes. Each course can offer a‬
‭unique and engaging experience for players‬‭.‬

‭2.1.3.‬‭Game complete screen:‬

‭Here , when we complete a level this screen shows to go next level.‬

‭2.1.4.‬ ‭Retry Screen:‬

I‭ f‬ ‭the‬ ‭allowed‬ ‭shots‬ ‭per‬ ‭round‬ ‭finish‬ ‭then‬ ‭a‬ ‭screen‬ ‭which‬ ‭shows‬
‭retry pops up.‬

‭12‬
‭2.2‬ ‭NON-FUNCTIONAL REQUIREMENTS‬

‭2.2.1‬‭Availability‬
‭The game will be available and run without‬‭any errors.‬
‭2.2.2 Security‬
‭Users‬ ‭can‬ ‭have‬ ‭secured‬ ‭access.‬ ‭There‬ ‭are‬ ‭no‬
‭restrictions in use of this game.‬

‭2.2.3 Maintainability‬
‭The admin doesn't have to maintain the game regularly.‬
‭3.2.4 Reliability‬
‭The game can be used by PC users.‬

‭13‬
 ‭CHAPTER 3‬

‭DESIGN‬

‭USER INTERFACE‬

‭Fig. 3.1‬

‭Fig. 3.2‬

‭14‬
‭Fig. 3.3‬

‭Fig. 3.4‬

‭15‬
‭Fig. 3.5‬

‭Fig. 3.6‬

‭16‬
 ‭CHAPTER 4‬

‭IMPLEMENTATION AND TESTING‬

‭4.1‬‭MAIN CODE FRAGMENTS‬

‭4.1.1 LEVEL MANAGER‬

‭ sing UnityEngine;‬
u
‭/// <summary>‬
‭/// Script responsible for managing level, like spawning level, spawning‬
‭balls, deciding game win/loss status and more‬
‭/// </summary>‬
‭public class LevelManager : MonoBehaviour‬
‭{‬
‭public static LevelManager instance;‬

‭ ublic GameObject ballPrefab;

p //reference to ball prefab‬
‭public Vector3 ballSpawnPos; //reference to spawn position of‬
‭ball‬

‭public LevelData[] levelDatas; //list of all the available levels‬

‭private int shotCount = 0; //count to store available shots‬

‭ rivate void Awake()‬

p
‭{‬
‭if (instance == null)‬
‭{‬
‭instance = this;‬
‭}‬
‭else‬
‭{‬
‭Destroy(gameObject);‬
‭}‬
‭}‬

‭17‬
 /‭// <summary>‬
‭/// Method to spawn level‬
‭/// </summary>‬
‭public void SpawnLevel(int levelIndex)‬
‭{‬
‭//we spawn the level prefab at required position‬
‭Instantiate(levelDatas[levelIndex].levelPrefab, Vector3.zero,‬
‭Quaternion.identity);‬
‭shotCount = 8; //set the available shots‬
‭UIManager.instance.ShotText.text = shotCount.ToString();‬
‭//set the ShotText text‬
‭//then we Instantiate the ball at‬
‭spawn position‬
‭GameObject ball = Instantiate(ballPrefab, ballSpawnPos,‬
‭Quaternion.identity);‬
‭CameraFollow.instance.SetTarget(ball); //set the‬
‭camera target‬
‭GameManager.singleton.gameStatus = GameStatus.Playing;‬
‭//set the game status to playing‬
‭}‬

/‭// <summary>‬
‭/// Method used to reduce shot‬
‭/// </summary>‬
‭public void ShotTaken()‬
‭{‬
‭if (shotCount > 0) //if shotcount is more‬
‭than 0‬
‭{‬
‭shotCount--; //reduce it by 1‬
‭UIManager.instance.ShotText.text = "" + shotCount; //set the‬
‭text‬

‭if (shotCount <= 0) //if shotCount is less‬

‭than 0‬
‭{‬
‭LevelFailed(); //Level failed‬

‭18‬
 ‭}‬
‭}‬
‭}‬

/‭// <summary>‬
‭/// Method called when player failed the level‬
‭/// </summary>‬
‭public void LevelFailed()‬
‭{‬
‭if (GameManager.singleton.gameStatus == GameStatus.Playing)‬
‭//check if the gamestatus is playing‬
‭{‬
‭GameManager.singleton.gameStatus = GameStatus.Failed; //set‬
‭gamestatus to failed‬
‭UIManager.instance.GameResult(); //call GameResult method‬

‭}‬
‭}‬

/‭// <summary>‬
‭/// Method called when player win the level‬
‭/// </summary>‬
‭public void LevelComplete()‬
‭{‬
‭if (GameManager.singleton.gameStatus == GameStatus.Playing)‬
‭//check if the gamestatus is playing‬
‭{ //check if currentLevelIndex is less than total levels available‬
‭if (GameManager.singleton.currentLevelIndex <‬
‭levelDatas.Length)‬
‭{‬
‭GameManager.singleton.currentLevelIndex++; //increase the‬
‭count by 1‬
‭}‬
‭else‬
‭{‬
‭//else start from level 0‬
‭GameManager.singleton.currentLevelIndex = 0;‬
‭}‬

‭19‬
 ‭ ameManager.singleton.gameStatus = GameStatus.Complete;‬
G
‭//set gamestatus to Complete‬
‭UIManager.instance.GameResult(); //call‬
‭GameResult method‬
‭}‬
‭}‬
‭}‬

‭4.1.2 LEVEL DATA‬

‭using UnityEngine;‬

/‭// <summary>‬
‭/// Class which store level data‬
‭/// </summary>‬
‭[System.Serializable]‬
‭public class LevelData‬
‭{‬
‭public int shotCount; //maximum shot player can take‬
‭public GameObject levelPrefab; //reference to level prefab‬

‭ ublic LevelData()‬
p
‭{‬
‭shotCount = 5;‬
‭}‬
‭}‬

‭4.1.3 BALL CONTROL‬

‭using UnityEngine;‬

/‭// <summary>‬
‭/// Script which controls the ball‬
‭/// </summary>‬
‭[RequireComponent(typeof(Rigidbody))]‬
‭public class BallControl : MonoBehaviour‬
‭{‬
‭public static BallControl instance;‬

‭20‬
 [‭ SerializeField] private LineRenderer lineRenderer; //reference to‬
‭lineRenderer child object‬
‭[SerializeField] private float MaxForce; //maximum force that‬
‭an be applied to ball‬
‭[SerializeField] private float forceModifier = 0.5f; //multipliers of‬
‭force‬
‭[SerializeField] private GameObject areaAffector; //reference to‬
‭sprite object which show area around ball to click‬
‭[SerializeField] private LayerMask rayLayer; //layer allowed to‬
‭be detected by ray‬

‭ rivate float force;

p //actuale force which is‬
‭applied to the ball‬
‭private Rigidbody rgBody; //reference to rigidbody‬
‭attached to this gameobject‬
‭/// <summary>‬
‭/// The below variables are used to decide the force to be applied to the‬
‭ball‬
‭/// </summary>‬
‭private Vector3 startPos, endPos;‬
‭private bool canShoot = false, ballIsStatic = true; //bool to make‬
‭shooting stopping ball easy‬
‭private Vector3 direction; //direction in which the ball‬
‭will be shot‬

‭ rivate void Awake()‬

p
‭{‬
‭if (instance == null)‬
‭{‬
‭instance = this;‬
‭}‬
‭else‬
‭{‬
‭Destroy(gameObject);‬
‭}‬

r‭ gBody = GetComponent<Rigidbody>(); //get reference to‬

‭the rigidbody‬

‭21‬
 ‭}‬

/‭/ Update is called once per frame‬

‭void Update()‬
‭{‬
‭if (rgBody.velocity == Vector3.zero && !ballIsStatic) //if velocity is‬
‭zero and ballIsStatic is false‬
‭{‬
‭ballIsStatic = true; //set ballIsStatic to true‬
‭LevelManager.instance.ShotTaken(); //inform‬
‭LevelManager of shot taken‬
‭rgBody.angularVelocity = Vector3.zero; //set angular‬
‭velocity to zero‬
‭areaAffector.SetActive(true); //activate areaAffector‬
‭}‬
‭}‬

‭ rivate void FixedUpdate()‬

p
‭{‬
‭if (canShoot) //if canSHoot is true‬
‭{‬
‭canShoot = false; //set canShoot to false‬
‭ballIsStatic = false; //set ballIsStatic to false‬
‭direction = startPos - endPos; //get the direction‬
‭between 2 vectors from start to end pos‬
‭rgBody.AddForce(direction * force, ForceMode.Impulse); //add‬
‭force to the ball in given direction‬
‭areaAffector.SetActive(false); //deactivate‬
‭areaAffector‬
‭UIManager.instance.PowerBar.fillAmount = 0; //reset the‬
‭powerBar to zero‬
‭force = 0; //reset the force to zero‬
‭startPos = endPos = Vector3.zero; //reset the vectors‬
‭to zero‬
‭}‬
‭}‬

‭// Unity native Method to detect colliding objects‬

‭22‬
 ‭ rivate void OnTriggerEnter(Collider other)‬
p
‭{‬
‭if (other.name == "Destroyer") //if the object name‬
‭is Destroyer‬
‭{‬
‭LevelManager.instance.LevelFailed(); //Level Failed‬
‭}‬
‭else if (other.name == "Hole") //if the object name‬
‭is Hole‬
‭{‬
‭LevelManager.instance.LevelComplete(); //Level‬
‭Complete‬
‭}‬
‭}‬

‭public void MouseDownMethod() //method‬

‭called on mouse down by InputManager‬
‭{‬
‭if(!ballIsStatic) return; //no mouse‬
‭detection if ball is moving‬
‭startPos = ClickedPoint(); //get the vector‬
‭in word space‬
‭lineRenderer.gameObject.SetActive(true); //activate‬
‭lineRenderer‬
‭lineRenderer.SetPosition(0, lineRenderer.transform.localPosition);‬
‭//set its 1st position‬
‭}‬

‭ ublic void MouseNormalMethod()

p //method‬
‭called by InputManager‬
‭{‬
‭if(!ballIsStatic) return; //no mouse‬
‭detection if ball is moving‬
‭endPos = ClickedPoint(); //get the‬
‭vector in word space‬
‭force = Mathf.Clamp(Vector3.Distance(endPos, startPos) *‬
‭forceModifier, 0, MaxForce); //calculate the force‬

‭23‬
 ‭ IManager.instance.PowerBar.fillAmount = force / MaxForce;‬
U
‭//set the powerBar image fill amount‬
‭//we convert the endPos to local pos for ball as lineRenderer is child‬
‭of ball‬
‭lineRenderer.SetPosition(1,‬
‭transform.InverseTransformPoint(endPos)); //set its 1st position‬
‭}‬

‭ ublic void MouseUpMethod()

p //method‬
‭called by InputManager‬
‭{‬
‭if(!ballIsStatic) return; //no mouse‬
‭detection if ball is moving‬
‭canShoot = true; //set canShoot true‬
‭lineRenderer.gameObject.SetActive(false); //deactive‬
‭lineRenderer‬
‭}‬

/‭// <summary>‬
‭/// Method used to convert the mouse position to the world position in‬
‭respect to Level‬
‭/// </summary>‬
‭Vector3 ClickedPoint()‬
‭{‬
‭Vector3 position = Vector3.zero; //get a new‬
‭Vector3 varialbe‬
‭var ray = Camera.main.ScreenPointToRay(Input.mousePosition);‬
‭//create a ray from camera in mouseposition direction‬
‭RaycastHit hit = new RaycastHit(); //create a‬
‭RaycastHit‬
‭if (Physics.Raycast(ray, out hit, Mathf.Infinity, rayLayer)) //check‬
‭for the hit‬
‭{‬
‭position = hit.point; //save the hit point in‬
‭position‬
‭}‬
‭return position; //return position‬
‭}‬

‭24‬
 ‭#if UNITY_EDITOR‬

‭ rivate void OnDrawGizmosSelected()‬

p
‭{‬
‭Gizmos.color = Color.red;‬
‭Gizmos.DrawWireSphere(transform.position, 1.5f);‬
‭}‬

‭#endif‬

‭}‬

‭4.1.4. INPUT MANAGER‬

‭using UnityEngine;‬

/‭// <summary>‬
‭/// Script which detect mouse click and decide who will take input Ball‬
‭or Camera‬
‭/// </summary>‬
‭public class InputManager : MonoBehaviour‬
‭{‬
‭[SerializeField]‬
‭private float distanceBetweenBallAndMouseClickLimit = 1.5f;‬
‭//variable to decide who will take input Ball or Camera‬

‭ rivate float distanceBetweenBallAndMouseClick;

p //variable‬
‭to track the distance‬
‭private bool canRotate = false; //bool‬

/‭/ Update is called once per frame‬

‭void Update()‬
‭{‬
‭if (GameManager.singleton.gameStatus != GameStatus.Playing)‬
‭return; //if gameStatus is not playing, return‬

‭25‬
 i‭f (Input.GetMouseButtonDown(0) && !canRotate) //if‬
‭mouse button is clicked and canRotate is false‬
‭{‬
‭GetDistance(); //get the distance between‬
‭mouseClick point and ball‬
‭canRotate = true; //set canRotate to true‬

/‭/if distance is less than the limit allowed‬

‭if (distanceBetweenBallAndMouseClick <=‬
‭distanceBetweenBallAndMouseClickLimit)‬
‭{‬
‭BallControl.instance.MouseDownMethod(); //we control‬
‭the ball‬
‭}‬
‭}‬

i‭f (canRotate) //if canRotate is true‬

‭{‬
‭if (Input.GetMouseButton(0)) //if mousebutton is‬
‭clicked‬
‭{ //if distance is less than the‬
‭limit allowed‬
‭if (distanceBetweenBallAndMouseClick <=‬
‭distanceBetweenBallAndMouseClickLimit)‬
‭{‬
‭BallControl.instance.MouseNormalMethod(); //call ball‬
‭method‬
‭}‬
‭else‬
‭{ //else call camera method‬

‭CameraRotation.instance.RotateCamera(Input.GetAxis("Mouse X"));‬
‭}‬
‭}‬

‭if (Input.GetMouseButtonUp(0)) //on mouse click‬

‭is left‬
‭{‬

‭26‬
 ‭canRotate = false; //canRotate is set false‬
‭//if distance is less than the limit‬
‭allowed‬
i‭f (distanceBetweenBallAndMouseClick <=‬
‭distanceBetweenBallAndMouseClickLimit)‬
‭{‬
‭BallControl.instance.MouseUpMethod(); //call ball‬
‭method‬
‭}‬
‭}‬
‭}‬
‭}‬

/‭// <summary>‬
‭/// Method which give us distance between click point in world and‬
‭ball‬
‭/// </summary>‬
‭void GetDistance()‬
‭{‬
‭//we create a plane whose mid point is at ball position and whose‬
‭normal is toward Camera‬
‭var plane = new Plane(Camera.main.transform.forward,‬
‭BallControl.instance.transform.position);‬
‭var ray = Camera.main.ScreenPointToRay(Input.mousePosition);‬
‭//create a ray‬
‭float dist; //varibale to get ditance‬
‭if (plane.Raycast(ray, out dist))‬
‭{‬
‭var v3Pos = ray.GetPoint(dist); //get the point‬
‭at the given distance‬
‭//calculate the distance‬
‭distanceBetweenBallAndMouseClick = Vector3.Distance(v3Pos,‬
‭BallControl.instance.transform.position);‬
‭}‬
‭}‬

‭}‬

‭27‬
‭4.1.5 GAME MANAGER‬

‭using UnityEngine;‬

‭ ublic class GameManager : MonoBehaviour‬

p
‭{‬
‭public static GameManager singleton;‬

[‭ HideInInspector]‬
‭public int currentLevelIndex;‬
‭[HideInInspector]‬
‭public GameStatus gameStatus = GameStatus.None;‬

‭ rivate void Awake()‬

p
‭{‬
‭if (singleton == null)‬
‭{‬
‭singleton = this;‬
‭DontDestroyOnLoad(gameObject);‬
‭}‬
‭else‬
‭{‬
‭Destroy(gameObject);‬
‭}‬
‭}‬
‭}‬

[‭ System.Serializable]‬
‭public enum GameStatus‬
‭{‬
‭None,‬
‭Playing,‬
‭Failed,‬
‭Complete‬
‭}‬

‭28‬
‭4.1.6 CAMERA FOLLOW‬

‭ sing System.Collections;‬
u
‭using System.Collections.Generic;‬
‭using UnityEngine;‬

/‭// <summary>‬
‭/// Script which makes camera follow ball‬
‭/// </summary>‬
‭public class CameraFollow : MonoBehaviour‬
‭{‬
‭public static CameraFollow instance;‬

[‭ SerializeField] private ActiveVectors activeVectors; //class which‬

‭decide axis allowed to follow‬

‭ rivate GameObject followTarget;

p //reference target to‬
‭follow‬
‭private Vector3 offset; //offset between camera‬
‭and ball‬
‭private Vector3 changePos; //keep track of camera‬
‭pos‬

‭ rivate void Awake()‬

p
‭{‬
‭if (instance == null) instance = this;‬
‭else Destroy(gameObject);‬
‭}‬

/‭// <summary>‬
‭/// Method to set target from other scripts‬
‭/// </summary>‬
‭public void SetTarget(GameObject target)‬
‭{‬
‭followTarget = target; //set the target‬
‭offset = followTarget.transform.position - transform.position; //set‬
‭the offset‬

‭29‬
 c‭ hangePos = transform.position; //set the‬
‭changePos‬
‭}‬

/‭// <summary>‬
‭/// Unity method, we use lateUpdate as we want to change our camera‬
‭position after Update method‬
‭/// </summary>‬
‭private void LateUpdate()‬
‭{‬
‭if (followTarget) //if target is present‬
‭{‬
‭if (activeVectors.x) //if x axis is allowed‬
‭{ //set the changePos x‬
‭changePos.x = followTarget.transform.position.x - offset.x;‬
‭}‬
‭if (activeVectors.y) //if y axis is allowed‬
‭{ //set the changePos y‬
‭changePos.y = followTarget.transform.position.y - offset.y;‬
‭}‬
‭if (activeVectors.z) //if z axis is allowed‬
‭{ //set the changePos z‬
‭changePos.z = followTarget.transform.position.z - offset.z;‬
‭}‬
‭transform.position = changePos; //set the‬
‭transform of camera‬
‭}‬
‭}‬
‭}‬

[‭ System.Serializable]‬
‭public class ActiveVectors‬
‭{‬
‭public bool x, y, z;‬
‭}‬

‭30‬
 ‭4.1.7 UI MANAGER‬

‭ sing UnityEngine;‬
u
‭using UnityEngine.UI;‬
‭using UnityEngine.SceneManagement;‬

/‭// <summary>‬
‭/// Script to control game UI‬
‭/// </summary>‬
‭public class UIManager : MonoBehaviour‬
‭{‬
‭public static UIManager instance;‬

[‭ SerializeField] private Image powerBar; //ref to powerBar image‬

‭[SerializeField] private Text shotText; //ref to shot info text‬
‭[SerializeField] private GameObject mainMenu, gameMenu,‬
‭gameOverPanel, retryBtn, nextBtn; //important gameobjects‬
‭[SerializeField] private GameObject container, lvlBtnPrefab;‬
‭//important gameobjects‬

‭ ublic Text ShotText { get { return shotText; } } //getter for shotText‬

p
‭public Image PowerBar { get => powerBar; } //getter for powerBar‬

‭ rivate void Awake()‬

p
‭{‬
‭if (instance == null)‬
‭{‬
‭instance = this;‬
‭}‬
‭else‬
‭{‬
‭Destroy(gameObject);‬
‭}‬

‭powerBar.fillAmount = 0; //set the fill amount to zero‬

‭}‬

‭void Start()‬

‭31‬
 ‭{‬
‭if (GameManager.singleton.gameStatus == GameStatus.None) //if‬
‭gamestatus is none‬
‭{‬
‭CreateLevelButtons(); //create level buttons‬
‭} //we check for game status, failed or complete‬
‭else if (GameManager.singleton.gameStatus == GameStatus.Failed ||‬
‭GameManager.singleton.gameStatus == GameStatus.Complete)‬
‭{‬
‭mainMenu.SetActive(false); //deavtivate‬
‭main menu‬
‭gameMenu.SetActive(true); //activate game‬
‭menu‬

‭ evelManager.instance.SpawnLevel(GameManager.singleton.currentLevelIndex‬
L
‭); //spawn level‬
‭}‬
‭}‬

/‭// <summary>‬
‭/// Method which spawn levels button‬
‭/// </summary>‬
‭void CreateLevelButtons()‬
‭{‬
‭//total count is number of level datas‬
‭for (int i = 0; i < LevelManager.instance.levelDatas.Length; i++)‬
‭{‬
‭GameObject buttonObj = Instantiate(lvlBtnPrefab,‬
‭container.transform); //spawn the button prefab‬
‭buttonObj.transform.GetChild(0).GetComponent<Text>().text = "" +‬
‭(i + 1); //set the text child‬
‭Button button = buttonObj.GetComponent<Button>();‬
‭//get the button componenet‬
‭button.onClick.AddListener(() => OnClick(button));‬
‭//add listner to button‬
‭}‬
‭}‬

‭32‬
 /‭// <summary>‬
‭/// Method called when we click on button‬
‭/// </summary>‬
‭void OnClick(Button btn)‬
‭{‬
‭mainMenu.SetActive(false);‬
‭//deactivate main menu‬
‭gameMenu.SetActive(true); //activate‬
‭game manu‬
‭GameManager.singleton.currentLevelIndex =‬
‭btn.transform.GetSiblingIndex(); ; //set current level equal to sibling index on‬
‭button‬

‭ evelManager.instance.SpawnLevel(GameManager.singleton.currentLevelIndex‬
L
‭); //spawn level‬
‭}‬

/‭// <summary>‬
‭/// Method call after level fail or win‬
‭/// </summary>‬
‭public void GameResult()‬
‭{‬
‭switch (GameManager.singleton.gameStatus)‬
‭{‬
‭case GameStatus.Complete: //if completed‬
‭gameOverPanel.SetActive(true); //activate game finish‬
‭panel‬
‭nextBtn.SetActive(true); //activate next button‬

‭SoundManager.instance.PlayFx(FxTypes.GAMECOMPLETEFX);‬
‭break;‬
‭case GameStatus.Failed: //if failed‬
‭gameOverPanel.SetActive(true); //activate game finish‬
‭panel‬
‭retryBtn.SetActive(true); //activate retry button‬
‭SoundManager.instance.PlayFx(FxTypes.GAMEOVERFX);‬
‭break;‬
‭}‬

‭33‬
 ‭}‬

/‭/method to go to main menu‬

‭public void HomeBtn()‬
‭{‬
‭GameManager.singleton.gameStatus = GameStatus.None;‬

‭SceneManager.LoadScene(SceneManager.GetActiveScene().buildIndex);‬
‭}‬

/‭/method to reload scene‬

‭public void NextRetryBtn()‬
‭{‬

‭SceneManager.LoadScene(SceneManager.GetActiveScene().buildIndex);‬
‭}‬

‭}‬

‭34‬
‭4.2 FUNCTIONAL TESTING‬

‭4.2.1 FR1-Main Menu Screen‬

‭•‬ ‭Test‬‭the‬‭main‬‭menu‬‭screen‬‭ensuring‬‭the‬‭availability‬‭of‬
‭the desired levels.‬
‭•‬ ‭Verified‬ ‭that‬ ‭the‬ ‭selected‬ ‭level‬ ‭is‬ ‭loaded‬ ‭and‬ ‭ready‬‭to‬
‭play.‬

‭4.2.2 FR2-Diverse Courses‬

•‭ Attempt to create unique and engaging golf courses.‬

‭• Verified that the diversity and playability of the courses‬
‭are ensured.‬

‭4.2.3 FR3-Game complete screen‬

•‭ ‬ ‭On‬ ‭a‬‭successful‬‭putt(putting‬‭the‬‭golf‬‭ball‬‭in‬‭the‬‭hole),‬‭the‬
‭game‬ ‭complete‬ ‭screen‬ ‭appears‬ ‭and‬ ‭offers‬ ‭the‬ ‭option‬ ‭to‬ ‭proceed‬ ‭to‬
‭the next course/level .‬

‭4.2.4 FR4-Retry Screen‬

‭4.2.4.1 Test Case 1: Ball out of bounds‬

•‭ ‬‭When‬‭the‬‭golf‬‭ball‬‭has‬‭been‬‭hit‬‭out‬‭of‬‭the‬‭bounds‬‭of‬
‭the golf course, the retry screen appears.‬

‭4.2.4.2 Test Case 2: Out of shots left‬

•‭ ‬ ‭When‬ ‭no‬‭more‬‭shots‬‭are‬‭available‬‭to‬‭the‬‭player,‬‭the‬
‭retry screen appears.‬

‭35‬
‭4.3 SOFTWARE TESTING‬

‭4.3.1 Performance Testing :‬

‭Simulate‬‭a‬‭high‬‭number‬‭of‬‭concurrent‬‭users‬‭scheduling‬‭trash‬
‭pickups to ensure the system can handle the load.‬
‭4.3.2 Security Testing:‬
‭Tested‬ ‭the‬ ‭system‬ ‭for‬ ‭any‬ ‭vulnerabilities,‬ ‭such‬ ‭as‬
‭unauthorised access or data breaches.‬
‭4.3.3 Compatibility Testing:‬
‭Test‬ ‭the‬ ‭app‬ ‭on‬ ‭different‬ ‭devices,‬ ‭operating‬ ‭systems,‬ ‭and‬
‭screen‬ ‭resolutions‬ ‭to‬ ‭ensure‬ ‭compatibility‬ ‭and‬ ‭proper‬
‭functionality.‬

‭ hese‬ ‭testing‬ ‭activities‬ ‭aim‬ ‭to‬ ‭ensure‬ ‭that‬ ‭the‬ ‭"Mini-Golf"‬ ‭app‬
T
‭performs‬ ‭optimally,‬‭maintains‬‭security,‬‭functions‬‭seamlessly‬‭across‬
‭different‬ ‭platforms,‬ ‭and‬ ‭provides‬ ‭a‬ ‭user-friendly‬ ‭experience‬ ‭for‬ ‭its‬
‭users.‬

‭36‬
 ‭CHAPTER 5‬

‭RESULTS AND DISCUSSIONS‬

‭RESULTS AND DISCUSSIONS‬

‭ ithin‬ ‭this‬ ‭section,‬ ‭we‬ ‭will‬ ‭delve‬ ‭into‬ ‭the‬ ‭examination‬ ‭of‬ ‭our‬
W
‭game’s‬ ‭testing‬ ‭phase.‬ ‭This‬ ‭phase‬ ‭was‬ ‭conducted‬ ‭to‬ ‭assess‬ ‭the‬
‭effectiveness‬‭of‬‭our‬‭game’s‬‭core‬‭functionalities,‬‭gauge‬‭their‬‭ease‬‭of‬
‭use,‬ ‭and‬ ‭ascertain‬ ‭whether‬‭they‬‭met‬‭our‬‭performance‬‭criteria.‬‭Let's‬
‭delve‬ ‭into‬ ‭the‬ ‭discoveries‬ ‭we‬ ‭made,‬ ‭address‬ ‭any‬ ‭obstacles‬
‭encountered,‬ ‭and‬ ‭explore‬ ‭the‬ ‭implications‬ ‭of‬ ‭these‬ ‭findings‬ ‭on‬‭the‬
‭overall achievement of our game.‬

‭5.1.‬‭Main Menu Screen‬

‭ he‬ ‭examination‬ ‭of‬ ‭main‬ ‭menu‬ ‭screen‬ ‭functionality‬ ‭uncovered‬ ‭a‬

T
‭notably‬ ‭efficient‬ ‭way‬ ‭to‬ ‭select‬ ‭the‬ ‭desired‬ ‭level.‬‭Players‬‭found‬‭the‬
‭level‬ ‭selection‬ ‭process‬ ‭to‬ ‭be‬ ‭straightforward,‬ ‭and‬ ‭the‬ ‭loading‬ ‭of‬
‭level‬ ‭selected‬ ‭was‬ ‭consistently‬ ‭reliable.‬ ‭The‬ ‭ability‬ ‭to‬ ‭access‬ ‭the‬
‭levels‬ ‭of‬ ‭the‬ ‭game‬ ‭through‬ ‭a‬ ‭simple‬ ‭click‬ ‭was‬ ‭demonstrated.‬ ‭This‬
‭underscores‬ ‭the‬ ‭significance‬ ‭of‬ ‭a‬ ‭simple‬ ‭and‬ ‭user-friendly‬ ‭user‬
‭interface,‬ ‭which‬ ‭plays‬ ‭a‬ ‭pivotal‬ ‭role‬ ‭in‬ ‭fostering‬ ‭a‬ ‭positive‬ ‭user‬
‭experience.‬

‭37‬
 ‭Fig. 5.1‬

‭Main menu/level select screen‬

‭ .2.‬‭Diverse levels/courses‬
5
‭Upon successful selection of the level, the level is loaded and ready‬
‭to play.‬

‭Fig 5.2‬
‭Level screen‬

‭38‬
‭ .3.‬‭Game complete screen‬
5
‭When the player successfully putts the ball, the game complete‬
‭screen is displayed. The player can proceed to the next level by‬
‭clicking on the “next” button.‬

‭Fig. 5.3‬

‭Game complete Screen‬

‭ .4.‬‭Retry Screen‬
5
‭In‬ ‭the‬ ‭case‬‭that‬‭a‬‭player‬‭hits‬‭the‬‭ball‬‭out‬‭of‬‭the‬‭level‬‭bounds‬‭or‬‭the‬
‭player‬ ‭exhausts‬ ‭their‬ ‭available‬ ‭shots‬ ‭left,‬ ‭the‬ ‭game‬ ‭ends‬ ‭and‬ ‭the‬
‭player is presented with the option to retry the level.‬

‭39‬
 ‭Fig. 5.4‬

‭Retry screen‬

‭● RESULTS:‬

‭ he‬ ‭"Mini-Golf"‬ ‭game‬ ‭delivers‬ ‭a‬ ‭user-friendly,‬ ‭smooth,‬ ‭and‬

T
‭captivating‬ ‭gaming‬ ‭experience.‬ ‭Players‬ ‭are‬ ‭invited‬ ‭to‬ ‭embark‬‭on‬‭a‬
‭journey‬‭through‬‭five‬‭levels‬‭of‬‭increasing‬‭challenges,‬‭with‬‭each‬‭level‬
‭introducing‬ ‭a‬ ‭new‬ ‭layer‬ ‭of‬ ‭difficulty.‬ ‭The‬ ‭game‬ ‭provides‬ ‭an‬
‭immersive‬ ‭atmosphere,‬ ‭featuring‬ ‭lush‬ ‭virtual‬ ‭landscapes‬ ‭and‬
‭intricately‬‭designed‬‭courses‬‭that‬‭serve‬‭as‬‭a‬‭compelling‬‭backdrop‬‭for‬
‭players‬ ‭to‬ ‭refine‬ ‭their‬ ‭skills.‬ ‭With‬ ‭intuitive‬ ‭controls‬ ‭and‬ ‭dynamic‬
‭level‬ ‭progression,‬ ‭this‬ ‭Unity-based‬ ‭game‬‭is‬‭an‬‭excellent‬‭choice‬‭for‬
‭both‬ ‭casual‬ ‭enjoyment‬ ‭and‬ ‭competitive‬ ‭excitement‬ ‭in‬ ‭the‬ ‭virtual‬
‭golfing‬ ‭world.‬ ‭In‬ ‭essence,‬ ‭the‬ ‭"Mini-Golf"‬ ‭game‬ ‭enhances‬ ‭the‬
‭gaming‬‭experience‬‭by‬‭offering‬‭easy-to-use‬‭features‬‭and‬‭contributing‬
‭to user entertainment.‬

‭40‬
 ‭CHAPTER 6‬

‭CONCLUSION AND FUTURE SCOPE‬

‭6.1 CONCLUSION :‬

I‭ n‬ ‭conclusion,‬ ‭the‬ ‭"Mini-Golf"‬ ‭game‬ ‭has‬ ‭successfully‬

‭revolutionised‬ ‭the‬ ‭gaming‬ ‭experience‬ ‭by‬ ‭creating‬ ‭an‬ ‭engaging,‬
‭user-friendly,‬ ‭and‬ ‭intuitive‬ ‭entertainment‬ ‭solution.‬ ‭By‬ ‭combining‬
‭real‬‭world‬‭physics,‬‭the‬‭game‬‭allows‬‭users‬‭to‬‭effortlessly‬‭experience‬
‭the‬‭essence‬‭of‬‭the‬‭sport‬‭“golf”‬‭from‬‭their‬‭devices.‬‭The‬‭integration‬‭of‬
‭unity‬ ‭based‬ ‭object‬ ‭prefabs‬ ‭and‬ ‭scripts‬ ‭to‬ ‭model‬ ‭the‬ ‭behaviour‬ ‭of‬
‭these‬ ‭objects,‬ ‭helped‬ ‭in‬ ‭the‬ ‭creation‬ ‭of‬ ‭a‬ ‭simple‬ ‭yet‬ ‭sensational‬
‭game‬ ‭of‬ ‭golf.‬ ‭Throughout‬ ‭the‬ ‭project,‬ ‭an‬ ‭emphasis‬ ‭on‬ ‭user‬ ‭needs,‬
‭collaboration‬ ‭with‬ ‭stakeholders,‬ ‭and‬ ‭iterative‬ ‭development‬ ‭has‬
‭resulted‬ ‭in‬ ‭a‬ ‭seamless‬ ‭and‬ ‭delightful‬ ‭user‬ ‭experience.‬ ‭The‬
‭"Mini-Golf”‬ ‭game‬ ‭simplifies‬ ‭the‬ ‭gaming‬ ‭experience‬ ‭with‬ ‭simple‬
‭and‬ ‭smooth‬ ‭controls,‬ ‭realistic‬ ‭physics‬ ‭and‬ ‭an‬ ‭overall‬ ‭user‬ ‭friendly‬
‭user‬ ‭interface.‬ ‭Overall,‬ ‭the‬ ‭"Mini-Golf‬‭''‬‭game‬‭has‬‭transformed‬‭the‬
‭gaming‬ ‭landscape,‬ ‭providing‬ ‭convenience,‬ ‭efficiency,‬ ‭and‬ ‭a‬ ‭joyful‬
‭golfing experience for users.‬

‭6.2 FUTURE SCOPE :‬

‭ he future scope of the multimedia project, "Golf," developed using‬

T
‭C# utility, opens up exciting possibilities for enhancement and‬
‭expansion. The project can evolve by incorporating advanced‬
‭features that enable players to personalize their gaming experience.‬
‭This includes introducing customization options for golf balls and‬
‭putters, allowing players to express their individuality within the‬

‭41‬
‭ ame. Moreover, the addition of a mini golf course design feature‬
g
‭will empower players to create and share their unique courses,‬
‭fostering creativity and community engagement.‬

‭ o enrich the multiplayer experience, the project can explore‬

T
‭real-time online multiplayer modes, enabling players to compete or‬
‭collaborate in live matches. Leaderboards and tournaments can be‬
‭implemented to add a competitive edge, allowing players to gauge‬
‭their skills against others and participate in exciting challenges.‬
‭These multiplayer features aim to create a dynamic and socially‬
‭immersive gaming environment.‬

‭ ontinued development should also focus on expanding the game's‬

C
‭content to maintain player interest. This involves introducing new‬
‭mini golf courses with diverse themes, challenges, and unlockable‬
‭content. The infusion of fresh and engaging elements ensures that‬
‭players remain captivated and invested in the game over time.‬

‭ urthermore, the future iterations of the project could delve into the‬
F
‭integration of augmented reality (AR) and virtual reality (VR)‬
‭technologies, elevating the immersive experience for players by‬
‭blending the virtual and real worlds. The inclusion of customizable‬
‭avatars, equipment, and virtual environments will contribute to a‬
‭more tailored and interactive gaming experience.‬

I‭ n summary, the future scope envisions a technologically enriched,‬

‭socially engaging, and content-diverse iteration of the Golf game,‬
‭catering to a broad spectrum of gaming preferences and pushing the‬
‭boundaries of virtual sports entertainment.‬

‭42‬
‭REFERENCES:‬

‭ ‬ ‭Youtube video:‬‭https://youtu.be/dIGJ_ltO1Q0?feature=shared‬
●
‭●‬ ‭Unity Documentation:‬

‭-‬ ‭URL:‬‭[Unity‬‭Official‬‭Documentation](‬
‭https://docs.unity3d.com/‬‭)‬

‭-‬ ‭Utilized‬ ‭for‬ ‭comprehensive‬ ‭insights‬

‭into‬ ‭Unity‬ ‭functionalities,‬ ‭scripting,‬ ‭and‬
‭game development best practices.‬

‭●‬ ‭C# Programming Language Documentation:‬

‭-‬ ‭URL:‬ ‭[Microsoft‬ ‭C#‬

‭Documentation](‬‭https://docs.microsoft.c‬
‭om‬‭/en-us/dotnet/csharp/)‬

‭-‬ ‭Referred‬ ‭to‬ ‭for‬ ‭guidance‬ ‭on‬ ‭C#‬

‭language‬ ‭features,‬ ‭syntax,‬ ‭and‬ ‭optimal‬
‭practices in game development.‬

‭●‬ ‭Online Unity Community Forums:‬

‭-‬ ‭URL:‬‭[Unity‬‭Community‬‭Forums]‬
‭https://forum.unity.com‬‭/‬

‭-‬ ‭Explored‬ ‭for‬ ‭troubleshooting,‬

‭gaining‬ ‭insights,‬ ‭and‬ ‭seeking‬ ‭advice‬
‭from the Unity developer community.‬

‭43‬