BeeT 3D documentation

Beet 3D
A WORK-STUDY COMPUTER GAME
A PROJECT WORK SUBMITTED TO THE DEPARTMENT OF
COMPUTER SCIENCE AND INFORMATION TECHNOLOGY
BABCOCK UNIVERSITY
ILISHAN – REMO
OGUN STATE
NIGERIA
IN PARTIAL FULFILMENT OF THE REQUIREMENTS FOR THE
AWARD OF BACHELOR OF SCIENCE DEGREE IN COMPUTER
SCIENCE (INFORMATION SYSTEM)
BY:
BULURO, OLUWATOBI ENITAN
MATRIC NO: 12/3718
APRIL 2015

this page was intentionally left blank

DEDICATION
This project is dedicated to God Almighty and Babcock University Ilishan-Remo, Ogun Nigeria.

ACKNOWLEDGEMENT
I will like to thank God almighty for empowering me with wisdom, knowledge and
understanding and for sparing our lives till the completion of this project and beyond. We give
him praise and adoration.
I also want to appreciate my parents for their funding and support through the project
development phases. I also like to appreciate my project supervisor for his constant support,
tutorials and guidance towards the completion of my project and also the Unity 3D team for the
constant assistance with the use of their software.

ABSTRACT
A number of gaming software being developed do not consider the educational aspect of the gamer.
Their objectives are either to develop better versions of their games using high-end graphic
software or meet their own self-administered objective.
The issue of work-study ignorance in Babcock University has increased through the years.
Students now discourage attending any work-study activity due to fowl stories passed down
every year to new students. Students also get discouraged because they don’t fully understand
the idea behind work-study and community service.
This project bridges the gap between students and work-study program involvement by
developing a virtual environment which will teach students about working with their hands and
participation in a work-study program in Babcock University.

CONTENTS Page
Declaration..……..…………………………………………………………………………………i
Certification..……………………………………………………………………………………...ii
Dedication………………………………………………………………………………………...iii
Acknowledgement………………………………………………………………………………..iv
Abstract……………………………………………………………………………………………v
CHAPTER ONE: PROJECT INTRODUCTION
1.1 Introduction………………………………………………………………….…….1
1.2 Problem statement…………………………………………………………………2
1.3 Aim………………………………………………………………………………..3
1.4 General objectives…………………………………………………………………3
1.5 Methodology………………………………….…………………………………...3
1.6 Scope of the project…………………………………………………………….…4
1.7 Outcome of this project……………………………………………………………4
1.9 Organization of work…………………………………….………………………..5

CHAPTER TWO: LITERATURE REVIEW
2.1 Introduction………………………………………………………………….…….6
2.2 Game development in Africa……………………………………………………...7
2.3 2D – 3D generation………………………………………………………………..8
2.3.1 Side-scrolling games………..……………………………………………..9
2.3.1 Top-down perspective games……………………………………………..9
2.4 Roles……………………………………………………………………………..11
2.5 Education and Gaming in Nigeria…………….………………………………….12
2.6 Related works…………………………………………………………………….12
2.7 Tabular review of related works/articles…………………………………………14
2.8 Theoretical framework…………………………………………………………...15
CHAPTER THREE: METHODOLOGY AND SYSTEM DESIGN
3.1 Introduction………………………………………………………………….…...16
3.2 Software development process model…………………………………………...16
3.3 Design tools……………………………………………………………………...16
3.3.1 What is a game engine?……………………………………………….....17
3.3.2 Unity 3D game engine…..…………………………………………….....17

3.3.3 What is 3D Modelling?…………………………………………………..19
3.4 Modelling of the proposed system……………………………………………….20
3.5 The proposed system……...………………………….…………………………..21
3.6 User and system requirements…………….……………………………………..21
3.6.1 User requirements…………….……..,…………………………………..21
3.6.2 System requirements…………….…..,…………………………………..24
3.7 Hardware and software requirements……………………………………………25
3.7.1 Hardware requirements…………….……..,……………………………..25
3.7.2 Software requirements…………….……..,………………………….…..25
CHAPTER FOUR: SOFTWARE IMPLEMENTATION
4.1 Introduction………………………………………………………………….…..26
4.2 Game interface…………………………………………………….......................26
4.2.1 The character………………………………………..................................27
4.2.2 Main menu...………………………………………..................................28
4.2.3 Start game………………………………………......................................29
4.2.4 Back………………………………………...............................................33
4.2.5 Credits………………………………………............................................33

4.2.6 Quit………………………………………................................................33
4.3 Software testing………………………………………………………………….34
CHAPTER FIVE: SUMMARY, RECOMMENDATION AND CONCLUSION
5.1 Summary…..……………………………………………………………….…….35
5.2 Recommendations ………………………………….……………………………36
5.3 Conclusion……………………………………………………………………….36
References………………………………………………………………………………………..37
Appendix……………………………………………………………………………………….......i

LIST OF FIGURES
2.1 Awesomenaunts is a scrolling MOBA game…………………………….………..9
2.2 An example of a typical top-down, third-person view game, The Heist 2…..……9
2.3 First-person perspective as seen in STALKER: Shadow of Chernobly (2007)…...10
2.4 Call of Duty. An example of a 3rd person game…………………………………10
3.1 Player case diagram (Module 1)…………………………………………………10
3.2 Player case diagram (Module 2)…………………………………………………10
3.3 Player case diagram (Module 2A)………………………………………….……10
3.4 Player case diagram (Module 2B.………………………………………….……10
4.1 BeeT 3D configuration start page……….………………………………….........24
4.2 A student dressed in uniform for work-study……………………………………25
4.3 BeeT 3D configuration settings page…………………………………….………25
4.4 Main menu display……………………………………………………………….26
4.5 Sub main menu display………………………………………………………..…26
4.6 Main menu display………………….…………………………………………....27
4.7 Two students in work-study………………………..…………………….………29
4.8 The main gate of the school………………………..…………………….………29
4.9 A tuk-tuk (Keke) moving through the school…………………………………….29
4.10 Babcock Business School (BBS)…………………………………………………30

4.11 Babcock University teaching hospital (BUTH) ambulance………………………30
4.12 A plain view of the game environment…………………………………………...33
LIST OF TABLES
2.1 Examples of games and their release dates…………………………….………….7
2.2 Related works/articles…………………………………………………………....14

CHAPTER ONE
1.1 INTRODUCTION
Game playing is the design of artificial intelligence programs to be able to play more than one
game successfully. For many years, computers are programmed to play these games using
specially designed algorithms, which cannot be transferred to another context. For example, a
single player computer game program cannot play a multiplayer game. General game playing
was a project of the Stanford Logic Group of Stanford University, California which aims to
create a platform for general game playing.
There are other general game playing systems, which use their own languages for defining the
game rules. In 1992, Barney Pell developed the system Metagame. This system was able to play
a number of chess like games, given game rules definition in a special language.
In 1998, the commercial system, Zillions of Games was developed by Jeff Mallet and Mark
Lefler. The system used a LISP-like language to define the game rules. Zillions of games derived
the evaluation function automatically from the rules based on piece mobility, board structure and
game goals.
Simulation games began with Will Wright opening the Sim series in 1989 with SimCity, a city
building game. Certain games such as SimLife and SimEarth were subsequently created and are
capable of teaching players the basics of genetics and global ecosystem.
Simulation games aim to copy various activities form real life in form of a game for various
purposes such as training, analysis or prediction. Examples are business games, war games, role
playing games, war games or educational games. From three basic types of strategic, planning

and learning exercises: games, simulations and case studies, a number of hybrids may be
considered, including simulation games that are used as case studies.
1.2 PROBLEM STATEMENT
A lot of gaming software being developed do not consider the educational or moral aspect of the
gamer. Their objectives are either to develop better versions of their games using high-end graphic
software or meet their own self-administered objective(s).
Some simulation games that have also been developed also don’t consider the educational aspects
of the gamers. Since the development of games, the only widely sold game that portrays
developing countries like Nigeria, Iraq, etc. is Call of Duty – Advance Warfare.
Due to these challenges, my simulation game project adopts a developing country scenario
(Babcock University as case study) and impact educational concepts into the player of the game
through the use of student work study and the concept of Artificial Intelligence in gamification.

1.3 AIM
The aim of this project is to develop a game that will portray Babcock University as the case study
thus, allowing students or other players of the game to easily understand the concepts and
knowledge behind the development of the project. Thus, using an environment where players can
easily relate/interact which will make the game more interesting for the players.
1.4 GENERAL OBJECTIVES
1. To help the new and old students understand the concept of work study and its positive
effects on them by developing a virtual environment to simulate community service
scenarios.
2. To assist new students getting accustomed with Babcock University’s environment and
work study education.
3. To model the work-study program in 3D dimensional view. Thus, showing the students of
Technical Drawing courses and students of Computer Technology modelling techniques.
1.5 METHODOLOGY
Following the stated general objectives above, I will adopt a methodology in accordance with the
System Development Life Cycle (SDLC) to attain them:
 Methodology 1: To ascertain the viability of my project, I performed researches on Game
Development, understand the concept of simulation gaming and development, research on
educational games and study their methodologies to understand the concepts they used in
developing. Also under this phase I ascertained the cost of running the project and risk
management.

 Methodology 2: In this phase, I conducted series of interviews with stake holders (old/new
students of Babcock University and staff of the community service department) to find out
details needed for work-study, locations in school where students can perform the services
and also other requirements aimed towards Babcock University’s environment.
 Methodology 3: In this phase I used a software called Unity 3D for the construction of the
game’s environment in 3D dimensional view, MonoDevelop as an IIDE for scripting
(coding) and made use of modelling software like Maya 3ds Max and Maya Autodesk. I
also used system software like Paint and Pictures and an application software (Photoshop)
in editing images needed in the development of the 3D environment.
1.6 SCOPE OF THE PROJECT
The project emulates an environment (Babcock University) into virtual 3D and mimics an exact
replica of different structure and objects available in the school.
1.7 OUTCOME OF THIS PROJECT
A game called “BEET 3D” which will initially be developed for PC (Windows).

1.8 ORGANIZATION OF WORK
The game software will be made up of five chapters to be explained below:
Chapter One (Introduction)
Chapter Two (Literature Review): In this chapter, I discussed the brief summary of gaming and
simulations to understand its history and how it has evolved in the past years thus, showing me
how to better build my project.
Chapter Three (methodology and system design): In this chapter, I discussed the methodologies
used in the development of this game and also the design processes involved in the development.
Chapter Four (Implementation and Testing): In this chapter, I discussed the requirements,
specifications, implementation and testing of the software.
Chapter Five (Summary and Conclusions): In this chapter, I discussed my findings so far and
summarized the processes involved in the development of this project.

CHAPTER TWO
LITERATURE REVIEW
2.1 INTRODUCTION
Game development is the process of creating a game. The development may range from a single
developer to a large organization of developers. Commercial PC and console games are normally
developed by a publisher (e.g. EA sports, BT games, Capricon, etc.) and may take several years
to develop.
The development of the first video games in the 1950s needed mainframe computers which were
not available to the general public. With the introduction of the 1st generation of game consoles
in the 1970s, commercial game development started its wave of popularity, where game consoles
and home computers could be accessible by the public. Due to low costs and low capabilities of
computers, a lone programmer can develop a full game, but in a period of time depending on the
type of game to be developed. Computer Space was the first commercially sold video game. It
was a black-and-white game and the computers system was made of 74 series TTL chips (one of
the early chips found in early computer systems).
Due to the revolution of science in the 21st century, the price of a lone programmer creating a
game has risen to be quite expensive. But the development of mobile-based games have still
remained less expensive to no expense in some cases.
Console games and PC games are generally developed in phases. The pre-production phase,
where the developer(s) create prototype and write documents (e.g. a proposal to contain
concepts, gameplay, feature list, settings, audience, etc.) to be presented to sponsors, prototype to
be presented to a focus group of gamers, and other external bodies for the review of the

proposal/intended game. If the intended game is approved, the developer(s) may receive funding,
start advertisement, set a deadline date and then development of the game begins. In the
development of a major game, the developers range from different fields which include
programmers, artists, voice actors, designers, testers, sound effect, focus group, etc.
Mobile game development on the other hand is faster in its production. In most cases it takes less
than a year of production and mostly a lone developer in its development. Due to the small
market and investment needed for mobile game development, mobile game development is now
seen as an avenue for small businesses or individuals to enter the gaming industry.
Game development period ranges according to different factors which include genre of the game,
among other factors for game development. Some examples of games and their release dates are:
Game Development begins Date released
1. Spore 1999 2008
2. Prey 1997 2006
3. Duke Nuken Forever 1997 2011
4. Team Fortress 2 1998 2007
Table 2.1 - Examples of games and their release dates
2.2 Game development in Africa
Game development in Africa wasn’t a recognizable sector until recent times. The largest gaming
market in Africa is in South Africa. The market is overtaking the market in movies and music in
the country. In Nigeria, game development also started making wave when games like Call of
Duty, basketball games, FIFA football games among others started using our environments. The

use of our Nigerian environment in games inspires us to purchase those kind of games and also
produce games of ours.
Gaming companies like Gameplus Limited, Techline Communications, Simply Fun Limited,
Impedence Systems Company, Kuluya, among others, have been newly introduced companies
into the gaming sector. Kuluya for example focuses on developing games in which the
environment is Nigerian-based. The company also uses characters which are dark skinned to
make the games enjoyable from different perspective.
2.3 2D – 3D GENERATION
2D computer game graphics started in the 1950s which is based on vector graphics devices and is
the computer-based generation of digital images. 2D was mainly used in applications that were
originally developed upon traditional printing and drawing technologies, such as typography,
cartography, technical drawing, etc. Games utilizing parallel projection typically make use of
2D, allowing developers to create large, complex gameworlds efficiently and with relatively few
art assets. Examples of 2D driven games are:

2.3.1 Side-scrolling games
Fig 2.1 - Awesomenauts is a scrolling MOBA game.
2.3.2 Top-down perspective games
Fig 2.2 - An example of a typical top-down,
third-person view game, The Heist 2
With the introduction of 3D accelerated graphics, video games could go beyond the old
technology of 2D. in 3D games, real life scenarios and intended graphics are easily seen from
different perspectives. There has also been an introduction of backgrounds to 3D games due to
its flexibilities in movement and graphics.

There have also been different gaming graphical perspectives that come with 3D which include
1st person, 3rd person, Stereo graphics, among others.
1st person perspective example
Fig 2.3 - First-person perspective as seen in
STALKER: Shadow of Chernobly (2007).
3rd person perspective example
Fig 2.4 - Call of Duty. An example of a 3rd person game.

2.4 Roles
1. Producers: Internal producers working for the developers are known as internal
producers and manages the development team, staff etc. the producer may also be
referred to as project manager, project lead or director.
2. Publisher: Is responsible for the publishing of the develop game, also responsible for
advertising, marketing, and all the responsibilities a publisher in other sector is supposed
to have. They usually deal with finances of the project in some cases.
3. Designer: A designer is one who designs the gaming structure of the game, the
gameplay, rules, etc. the designer is in charge of the writing the story line of the game.
4. Artist: A game artist is one who creates game arts which his overseen by an art director.
The artist may be tasked with a 2D or 3D oriented work depending on the genre and other
factors of the game to be developed.
5. Development Team: The development team range from about 2 people to a team of 100.
The size of the team depends on the type of game to be developed. Like discussed above,
a mobile based game doesn’t need a very large development team (1 – 50), whereas, a PC
or console development team may rage higher from about 20 – 100 team members.
6. Programmers: A programmer is a software engineer who primarily develops video
games using game development tools like Unity 3d, 3D Max, etc. the coding aspect of the
game is handled by the programmer. Programming discipline roles include: physics, AI
(Artificial Intelligence), Gameplay, Sound programming, UI (User Interface), Scripting,
Game tools usage, etc.

7. Tester: Testers are in charge of making sure the quality expected from the game is met.
They test the game periodically during the development period to make sure that all
necessary expected features are met.
8. Focus Group: The focus group can be of about 3 – higher number of people. The can
function as testers but their main aim is to brain storm and figure out extra features to be
added to the game to be developed.
9. Maintenance group: After the release of a game, the maintenance phase for the game
begins. Series of updates become available in order to fix bugs on those released games.
2.5 Education and Gaming in Nigeria
Many universities in Nigeria don’t or never offer classes specifically focused on
game development. It is not yet seen as a relevance to schools in Nigeria to
include gaming as an aspect of Computer studies.
2.6 RelatedWorks (This is a review of related simulation gaming
software)
1. The Sims is a life simulation video game series developed by EA Maxis and published
by Electronic Ar. In The Sims, the players create virtual people called “Sims” and places
them in houses and help direct their moods and satisfy their desires.

The Sims 3 Minimum System Requirement
1. CPU (INTEL): Pentium 4 2.0GHz
2. CPU (AMD): Athlon XP
3. GPU (NVidia): GeForce 2 MX 400 64MB
4. GPU (AMD): Radeon 8500 Series 64MB
5. RAM: 1 GB
6. Operating System: Window 7
7. Direct X: DX 8
8. Hard Disk Drive Space: 4 GB
Even though The Sims was one of the first widely sold simulation games to be developed, it
never depicted the real life scenario of a developing country (e.g. Nigeria). The Sims not only
avoided the portraying of developing countries but got a lot of critics which based their
opinions that The Sims doesn’t teach young good morals. It was also developed to be played
on Microsoft Windows 7. Thus, compatibility issues occur.
2. Second Life is an online virtual world, developed by Linden Lab. Second life users create
virtual representations of themselves called avatars and are able to interact with other
avatars, places and objects. They can explore the world (known as the grid), meet other
residents, socialize, participate in individual and group activities, build, create, shop and
trade virtual property and services with one another.
Second Life Minimum System Requirement
1. GPU (NVidia): GeForce 2 MX 400 64MB
2. GPU (AMD): Radeon 8500 Series 64MB
3. RAM: 2 GB

4. Direct X: DX 8
5. (Note: the game is played online so no need for interior CPU requirements and operating
system requirements).
Second Life was also one of the first simulation games too be online based thus, meeting more
people from different geographical regions. But, its limit to only been able to be played online
makes it not easily accessible in developing countries due to the low quality internet capacity.
2.7 Tabular Review of RelatedWorks/Articles.
TITLE AUTHOR/PUBLISHER CONTRIBUTION GAP
1. The Sims Electronic Art Maxis First widely sold
Simulation game.
- Ignorance of
developing
countries.
- Compatibility
issues.
2. Second Life Linden Lab First online based
simulation game.
-ignorance of
developing
countries.
Table 2.2 – Related works/articles
With proper study of these works and gaps I’ve worked out tools and techniques to be used in
this project.
The programming tool to be used will be monoDevelop, game design tool will be Unity 3d, and
modelling tool would be Blender and Maya. This project will also be developed to match our
current location (Babcock University).

2.8 TheoreticalFramework
Fig 2.5 – Prefix model for Theoretical framework (Okoro R. et al, 2013)
In the development of this project, I followed the above theoretical framework in arriving at
certain findings and conclusions.

CHAPTER THREE
METHODOLOGY AND SYSTEM DESIGN
3.1 INTRODUCTION
This chapter reviews the different components of my game software by analysis of each system
and software component. There will be analysis of the software game features and properties.
3.2 SOFTWARE DEVELOPMENT PROCESS MODEL
The software development process model to be used will be the waterfall model because the
requirements and specifications are well-defined.
3.3 DESIGN TOOLS
To achieve my game software, I will make use of the following:
 A game engine (used to design the game environment, a general platform for which the
game will be worked upon).
 Two 3D modelling software (which will be used to design, construct and model objects
like humans, buildings and other rigid objects).

3.3.1 What is a Game Engine?
A game engine is a software framework designed for the creation and development of video
games. The core functionality typically provided by a game engine includes a rendering engine,
physics engine or collision detection, scripting, animation and artificial intelligence.
Game engines provide platform abstraction, allowing the same game to run on various platforms
including game consoles and mobile devices.
Examples of game engines:
Blender, Delta3D, Oxygine, Panda3D, Retribution Engine, Unreal Engine 4, Wire3D, 3D Rad,
Dim3, Unity 3D, ORX, etc.
For the development of this game software, I used Unity 3D game engine.
3.3.2 Unity 3D Game Engine
Unity is a cross-platform game creation software which consist of a game engine, Integrated
Development Environment (IDE) and monoDevelop (for scripting) developed by Unity
Technologies. It is used to develop video games for websites, desktop platforms, consoles and
mobile devices. First announced only for the Mac OS and since been extended to target more
than fifteen platforms.It is now the default software development kit (SDK) for the Nintendo
Wii.

Features of Unity 3D game engine
1. Rendering
The graphics engine targets Direct3D on Windows and Xbox 360, OpenGL on Mac,
Windows and Linux, OpenGL ES on android and iOS and other proprietary API’s on video
game consoles.
Unity supports assets and file formats from 3ds Max, Maya, Blender, Cinema 4D,
Cheetah3D, Adobe Photoshop, Adobe Fireworks and Algorithmic substance (these are
modelling software). These assets can be added to the game project, and managed through
Unity's graphical user interface.
2. Scripting
Unity game engine’s scripting is built on Mono (the open-source implementation of the
.NET Framework). I used UnityScript (a custom language; part of JavaScript), c# and Boo
(which has a python-inspired syntax). MonoDevelop is a build in IDE for the
implementation and coding in Unity.
3. Platform
Unity 3D supports multiple platforms. In the development of a game, unity can compile
the output of games to web browsers, mobile devices, desktops and consoles. Unity also
allows specification of texture compression and resolution settings for each platform the
game supports.
Currently supported platforms for Unity 3D include Windows 8, Windows Phone 8,
BlackBerry 10, Windows, Mac, Linux, Android, iOS, Unity Web Player, Adobe Flash,
PlayStation 3, PlayStation 4, Xbox 360, Xbox One and some other PlayStation platforms,
etc.

4. Asset store
Unity's Asset Store is home to a growing library of free and commercial assets created
both by Unity Technologies and also members of the community. A wide variety of assets
is available, covering everything from textures, models and animations to whole project
examples, tutorials and Editor Extensions. The assets are accessed from a simple interface
built into the Unity Editor and are downloaded and imported directly into your project.
5. Physics/Rigidbodies
Unity has NVIDIA PhysX physics engine built-in. This allows for unique emergent
behavior and has many useful features like real-time cloth simulation on arbitrary and
skinned meshes, thick ray casts, and collision layers.
Rigidbodies are physically simulated objects. You use Rigidbodies for things that the
player can push around, for example crates or loose objects, or you can move Rigidbodies
around directly by adding forces to it by scripting.
3.3.3 What is 3D modelling?
3D modelling is the process of developing a mathematical representation of any three-
dimensional surface of an object (either inanimate or living) via specialized software. The
product/result is called 3D model. Wikipedia, (2014).
For the development of the game software, I used Autodesk Maya and Autodesk 3ds Max.

a) Autodesk Maya
Autodesk Maya (also shortened as Maya) is a 3D graphics computer software that runs on
Windows, OS X and Linux. It is used to create interactive 3D applications, including video
games, animation films, TV series or visual effects.
b) Autodesk 3ds Max
Autodesk 3ds Max is a professional 3D computer graphics program for making 3D animations,
models, games and images. It has modelling capabilities, a flexible plugin architecture and can
be used on the Microsoft Windows platform. It is also used by game developers and for movie
effects and visualization.
3.4 MODELLING OF THE PROPOSEDSYSTEM
1. Terrain construction: A terrain is the ground in which all objects in Unity stand or are
placed. I created it using the “Create terrain” tool in Unity’s tool bar.
2. Weather and cloud: The cloud is formed by a weather simulation plugin available in Unity
game engine.
3. Buildings and structures: The buildings and structures in the game are constructed in
Autodesk Maya and 3ds Max and imported to Unity engine as rigid bodies.
4. Road path: the road path in our game was constructed using a “create road” asset from the
Unity Asset Store and plain from Unity’s Engine.

5. The game software will be a centered on Babcock University, using the university as her
case study, adopting structures in the university to be represented in the game.
3.5 THE PROPOSED SYSTEM
 Game interface
o Game menu
 Start game
Clicking the “Start game” icon sends a command to the system which
begins the game.
 About
Clicking the “About” icon displays a view of the developers of the game
software.
 Quit game
Clicking the “Quit game” icon sends a command to the system which
terminates the software.
3.6 USER AND SYSTEM REQUIREMENTS
3.6.1 USER REQUIREMENTS
STUDENT (PLAYER)
a. Student shall be able to start the game.
b. Student shall be able to create a new profile or load an old profile.

c. Student shall be able to play free roam.
d. Student shall be able to navigate to places of desire on the terrain.
e. Student shall be able to pause the game.
f. Student shall be able to quit the game.
Fig 3.1 – Player case diagram (Module 1)
Fig 3.2 – Player case diagram (Module 2)

Fig 3.3 – Player case diagram (Module 2A)
Fig 3.4 – Player case diagram (Module 2B)

3.6.2 SYSTEM REQUIREMENTS
a) FUNCTIONALREQUIREMENTS
When the user clicks start game on the main menu, the game loads up programmed levels form
the scripting and displays the interface to the screen for use by the player.
The player uses inputs on the keyboard to move and interact with objects in the game. The player
hits keys like Up Arrow, Left Arrow, Right Arrow and Down Arrow for movement of objects
(character, objects, etc.), Space Bar for Jumping, Left Shift key for sprinting or moving faster,
Escape (Esc.) For Menu option and the Track Pad for looking and direction. When these keys are
clicked, the system takes in the command, compares the input to the scripting I coded during
development and performs the desired action on display.
When the user clicks the Escape (Esc) button, the system also takes in the command, compares
with the right result for that input in the scripting and displays the Pause Menu Screen where the
user can also select to continue playing the game, read the About for the game and Quit the
game.
b) NONFUNCTIONALREQUIREMENTS
a. Game will load within seconds.
 Game should work fast without any hangs or buffer.
 Game should enhance its 3D abilities on different systems.
 Game should be able to run without help, assistance or installation of third party
software.

 Game will not consume RAM space in a system.
 Game software will be able to adapt to newly developed systems, thus, extensibility of
the software.
 Game software will show Babcock University in 3D and also have a view of future
infrastructure for the university.
3.7 HARDWARE AND SOFTWARE REQUIREMENTS
3.7.1 Hardware Requirements
a. RAM: 1 GB or more
b. System type: 64-bit Operating system
c. Direct X: DX 8 or more
d. Hard Disk Drive Space: 4 GB (minimum)
e. Minimum processor speed: 1.50GHz
3.7.2 Software Requirements
a. Unity 3D
b. Autodesk Maya
c. Autodesk 3ds Max
d. Microsoft Windows Operating System: Windows XP, Windows 7, Windows 8 and
Windows 10.

CHAPTER FOUR
SOFTWARE IMPLEMENTATION
4.1 INTRODUCTION
Implementation is process of integrating a plan, software design, requirements and algorithm into
software applications. It is the first phase to the successful completion of a software application.
The implementation of product software is the final link in the deployment chain of software
production and all requirements are evaluated to ensure quality software development before
delivering it to the end-users.
4.2 GAME INTERFACE
On game startup, configuration settings which includes graphic resolution and controller setting
appears which enables users to choose their most preferred functional settings whereby resolution
and quality can be adjusted as well gaming controls.
Fig 4.1 - BeeT 3D configuration start page

4.2.1 THE CHARACTER
The work-study character in the game is portrayed to dress like a proper person in service.
Fig 4.2 - A student dressed in uniform for work-study
Fig 4.3 - BeeT 3D configuration settings page

4.2.2 MAIN MENU
Fig 4.4 - Main menu display
As the game is launched, the first page to be displayed will be a sub main menu
Fig 4.5 - Sub main menu display
Once the “Click to begin” button is clicked, the next page to be displayed would be the main menu
where various options can be selected;

Fig 4.6 - Main menu display
4.2.3 START GAME
When the “Start Game” button is selected, a scene (Level 1) is loaded displaying the character in
a tuk-tuk (Keke) at a start point (Babcock University’s main gate) where the first objective is to
navigate to the University’s stadium.
When the objective (locate the Stadium) is completed, another level is loaded where the player
will be assigned his hostel, courses and other requirements of a student. Other objective include to
locate the cafeteria, perform certain work study roles like sweep, clear an area, etc., to gain points.
The gained points can be used to buy books at the book shop, buy refreshments and food items.
After completion of objectives, the free roam option can be selected where the player has the
opportunity to roam the university and explore certain areas in the school.
On exit, the current game play level will be saved and can be restored on return of the player.

a) AUDIO PLAYBACK
During game play, certain audio sounds are played in order to fully reproduce locations in the
University. The audio files were added by java scripts available in the appendix.
b) IMAGES OF LOCATIONS IN THE GAME
Fig 4.7 - Two students in work-study

Fig 4.8 - The main gate of the school
Fig 4.9 - A tuk-tuk (Keke) moving through the school

Fig 4.10 - Babcock Business School (BBS)
Fig 4.11 – Babcock University teaching hospital (BUTH) ambulance

Fig 4.12 - A plain view of the game environment
4.2.4 BACK
The back button is takes the player back to the sub-menu where the player has the options of quit
or resume the game.
4.2.5 CREDITS
When the “Credits” button is pressed a looped video sequence is started to display the credits for
the game development.
4.2.6 QUIT
The “Quit” button closes the game and ends every system process associated with BeeT 3D.

4.3 SOFTWARE TESTING
Software testing is the execution of the software with actual test data with goals like verify that
all requirements are implemented correctly, identifies defects before software deployment and
help improve quality and reliability.
The various testing techniques were implemented:
- Platform Testing: In platform testing, the game was tested on other devices such as
android devices (tabs and smart phones).
- Extensibility Testing: The game software was developed on a Windows 7 and Windows
8 system, thus, an extensibility test was conducted where the software was installed and
played on lower operating systems like Windows XP and higher operating systems like
Windows 8.1 and they all yielded positive outcomes.

CHAPTER FIVE
SUMMARY, RECOMMENDATION AND CONCLUSION
5.1 SUMMARY
Application of BeeT 3D for the familiarity of Babcock University using knowledge from artificial
intelligence, database management and JavaScript, Boo and C # will assist students or parents in easily
understanding the game environment (Babcock University).
The firstchapterof this projectintroducedthe aimof thisproject,problemswithcurrentlyusedengines
or game dimensioning and ways to tackle them.
The second chapter discussed research works done by other game developers and the problems
faced or discovered with the way I suggested to avoid them.
The third chapter discussed the system analysis and design phases to be followed and also the tools
to be used during software design.
The forth chapter explained the implementation of the system and a review of the performance of the
system which were further portrayed with diagrams from the game.
The fifth chaptersummarizesthe projectwithrecommendations for future versions or enhancements.

5.2 RECOMMENDATIONS
BeeT 3D game is extensible, thus, chances of future upgrades or modifications are possible.
Recommended future upgrades or modifications may include:
1. Availability of classroom lectures to fully simulate learning environment.
2. Transformation of the game’s objectives into free roam and objective oriented gameplay.
3. Game to be used in explanation of the concept of modelling & simulation, artificial
intelligence and Java Scripting language case study.
4. Full simulation of Babcock University to portray students, lecturers and other features
present or developed over time to aid easier understanding of the environment.
5.3 CONCLUSION
In conclusion, this project will serve the purpose for which it is being developed. It has been found
that players of car-games experience a thrill and fulfillment which they can never experience in
real life. Car controlled movement through Babcock University with the sole aim of reaching a
particular destination increases the player’s determination and concentration. Unlike in the real
world, you don't have to worry of accidents or getting hurt.

REFERENCES
Ken Jones, (1995). Simulations: “A handbook for teachers and trainers”.
Danny Saunders, Jacqui Severn: “Simulation and Games for Strategy and Policy
Planning”.
Michael Genesereth and Nathaniel Love. General Game Playing: Overview of the AAAI
Competition.
List of Gaming companies in Nigeria. Available at: www.companylist.org/companiesnigeria
(Retrieved 2014-10-07).
2D computer graphics. Available at: www.wikipedia.com/2dcomputer_graphics (Retrieved
2014-10-07).
First-person perspective. Available at: www.wikipedia.com/firstperson_perspecctive
(Retrieved 2014-10-07).
Virpi Ruohamaki. A simulation game for the development of administrative work
processes. (Retrieved 2014-10-07).
Danny Sauders: Introducing simulations and games for business. (Retrieved 2014-10-
06).
Thomas Grip. 4-Layers, A Narrative Design Approach. (Retrieved 2014-09-20).
David Jaques: Games, simulations and case studies – a review. (Retrieved 2014-10-07).
Jussi Holopainen and Staffan Björk. Game Design Patterns. (Retrieved 2014-10-07).
Dejaime Antonio de Oliveira Neto. Intelligent 2D Collision and Pixel Perfection
Precision. (Retrieved 2014-10-07).
Marko Nemberg. Beginning Guide to User Testing With Child. Available at:
www.gamedev.net/beginningguide. (Retrieved 2014-10-07).

Angel Cagle. The Pros and Cons of Going to College for Game Development/Design.
Available at: www.gamedev.net/prosandcons_college. (Retrieved 2014-10-07).
Ken Jones, (1995). Simulations: A handbook for teachers and trainers.
Danny Saunders, Jacqui Severn: Simulation and Games for Strategy and Policy
Planning.
Michael Genesereth and Nathaniel Love (1996): “Games and Simulations to Enhance
Quality Learning”.

APPENDIX
MAIN MENU JavaScript (.js)
#pragma strict
function OnGUI()
{
if (GUI.Button(Rect(210,200,300,40),"Start Game"))
{
Application.LoadLevel("plan");
}
if (GUI.Button(Rect(210,250,300,40),"Back"))
{
Application.LoadLevel("MainMenu");
}
if (GUI.Button(Rect(210,300,300,40),"Credits"))
{
Application.LoadLevel("Credits");
}
if (GUI.Button(Rect(210,350,300,40),"Quit"))
{
Application.Quit();
}
}
SUB MENU – JavaScript (.js)
#pragma strict
function OnGUI()
{
GUI.Box(Rect(520,0,300,40),"Welcome");
if (GUI.Button(Rect(520,500,300,40),"Click to begin"))
{
Application.LoadLevel("SubMenu");
}
}
FPS Input controller movement – JavaScript (.js)

private var motor : CharacterMotor;
// Use this for initialization
function Awake () {
motor = GetComponent(CharacterMotor);
}
// Update is called once per frame
function Update () {
// Get the input vectorfrom kayboard or analog stick
var directionVector = new Vector3(Input.GetAxis("Horizontal"), 0, Input.GetAxis("Vertical"));
if (directionVector != Vector3.zero) {
// Get the length of the directon vectorand then normalize it
// Dividing by the length is cheaper than normalizing when we already have the length anyway
var directionLength = directionVector.magnitude;
directionVector = directionVector / directionLength;
// Make sure the length is no bigger than 1
directionLength = Mathf.Min(1, directionLength);
// Make the input vector more sensitive towards the extremes and less sensitive in the middle
// This makes it easier to control slow speeds when using analog sticks
directionLength = directionLength * directionLength;
// Multiply the normalized direction vector by the modified length
directionVector = directionVector * directionLength;
}
// Apply the direction to the CharacterMotor
motor.inputMoveDirection = transform.rotation * directionVector;
motor.inputJump = Input.GetButton("Jump");
}
// Require a character controller to be attached to the same game object
@script RequireComponent (CharacterMotor)
@script AddComponentMenu ("Character/FPS Input Controller")
Mouse Look – C# (.cs)
using UnityEngine;
using System.Collections;
public class MouseLook : MonoBehaviour {

public enum RotationAxes { MouseXAndY= 0, MouseX= 1, MouseY= 2 }
public RotationAxes axes = RotationAxes.MouseXAndY;
public float sensitivityX = 15F;
public float sensitivityY = 15F;
public float minimumX = -360F;
public float maximumX = 360F;
public float minimumY = -60F;
public float maximumY = 60F;
float rotationY = 0F;
void Update ()
{
if (axes == RotationAxes.MouseXAndY)
{
float rotationX = transform.localEulerAngles.y + Input.GetAxis("Mouse X") * sensitivityX;
rotationY += Input.GetAxis("Mouse Y") * sensitivityY;
rotationY = Mathf.Clamp (rotationY, minimumY, maximumY);
transform.localEulerAngles = new Vector3(-rotationY, rotationX, 0);
}
else if (axes == RotationAxes.MouseX)
{
transform.Rotate(0, Input.GetAxis("Mouse X") * sensitivityX, 0);
}
else
{
rotationY += Input.GetAxis("Mouse Y") * sensitivityY;
rotationY = Mathf.Clamp (rotationY, minimumY, maximumY);
transform.localEulerAngles = new Vector3(-rotationY, transform.localEulerAngles.y, 0);
}
}
void Start ()
{
// Make the rigid body not change rotation
if (rigidbody)

rigidbody.freezeRotation = true;
}
}
CONTROLLER MOTOR JAVA SCRIPT
#pragma strict
#pragma implicit
#pragma downcast
// Does this script currently respond to input?
var canControl : boolean = true;
var useFixedUpdate : boolean = true;
// For the next variables, @System.NonSerialized tells Unity to not serialize the variable or show it in the inspector
view.
// Very handy for organization!
// The current global direction we want the character to move in.
@System.NonSerialized
var inputMoveDirection : Vector3 = Vector3.zero;
// Is the jump button held down? We use this interface instead of checking
// for the jump button directly so this script can also be used by AIs.
var inputJump : boolean = false;
class CharacterMotorMovement {
// The maximum horizontal speed when moving
var maxForwardSpeed : float = 100.0;
var maxSidewaysSpeed : float = 100.0;
var maxBackwardsSpeed : float = 100.0;
// Curve for multiplying speed based on slope (negative = downwards)

var slopeSpeedMultiplier : AnimationCurve = AnimationCurve(Keyframe(-90, 1), Keyframe(0, 1),
Keyframe(90, 0));
// How fast does the character change speeds? Higher is faster.
var maxGroundAcceleration : float = 30.0;
var maxAirAcceleration : float = 20.0;
// The gravity for the character
var gravity : float = 10.0;
var maxFallSpeed : float = 20.0;
// For the next variables, @System.NonSerialized tells Unity to not serialize the variable or show it in the
inspectorview.
// The last collision flags returned from controller.Move
var collisionFlags : CollisionFlags;
// We will keep track of the character's current velocity,
var velocity : Vector3;
// This keeps track of our current velocity while we're not grounded
var frameVelocity : Vector3 = Vector3.zero;
var hitPoint : Vector3 = Vector3.zero;
var lastHitPoint : Vector3 = Vector3(Mathf.Infinity, 0, 0);
}

var movement : CharacterMotorMovement = CharacterMotorMovement();
enum MovementTransferOnJump {
None, // The jump is not affected by velocity of floor at all.
InitTransfer, // Jump gets its initial velocity from the floor, then gradualy comes to a stop.
PermaTransfer, // Jump gets its initial velocity from the floor, and keeps that velocity until landing.
PermaLocked // Jump is relative to the movement of the last touched floor and will move togetherwith that
floor.
}
// We will contain all the jumping related variables in one helper class for clarity.
class CharacterMotorJumping {
// Can the character jump?
var enabled : boolean = true;
// How high do we jump when pressing jump and letting go immediately
var baseHeight : float = 1.0;
// We add extraHeight units (meters) on top when holding the button down longer while jumping
var extraHeight : float = 4.1;
// How much does the character jump out perpendicular to the surface on walkable surfaces?
// 0 means a fully vertical jump and 1 means fully perpendicular.
var perpAmount : float = 0.0;
// How much does the character jump out perpendicular to the surface on too steep surfaces?
// 0 means a fully vertical jump and 1 means fully perpendicular.
var steepPerpAmount : float = 0.5;
// For the next variables, @System.NonSerialized tells Unity to not serialize the variable or show it in the
inspectorview.
// Are we jumping? (Initiated with jump button and not grounded yet)

// To see if we are just in the air (initiated by jumping OR falling) see the grounded variable.
var jumping : boolean = false;
var holdingJumpButton : boolean = false;
// the time we jumped at (Used to determine for how long to apply extra jump power after jumping.)
var lastStartTime : float = 0.0;
var lastButtonDownTime : float = -100;
var jumpDir : Vector3 = Vector3.up;
}
var jumping : CharacterMotorJumping = CharacterMotorJumping();
class CharacterMotorMovingPlatform {
var movementTransfer : MovementTransferOnJump = MovementTransferOnJump.PermaTransfer;
var hitPlatform : Transform;
var activePlatform : Transform;
var activeLocalPoint : Vector3;

var activeGlobalPoint : Vector3;
var activeLocalRotation : Quaternion;
var activeGlobalRotation : Quaternion;
var lastMatrix : Matrix4x4;
var platformVelocity : Vector3;
var newPlatform : boolean;
}
var movingPlatform : CharacterMotorMovingPlatform = CharacterMotorMovingPlatform();
class CharacterMotorSliding {
// Does the character slide on too steep surfaces?
// How fast does the character slide on steep surfaces?
var slidingSpeed : float = 15;
// How much can the player control the sliding direction?
// If the value is 0.5 the player can slide sideways with half the speed of the downwards sliding speed.
var sidewaysControl : float = 1.0;

// How much can the player influence the sliding speed?
// If the value is 0.5 the player can speed the sliding up to 150% or slow it down to 50%.
var speedControl : float = 0.4;
}
var sliding : CharacterMotorSliding = CharacterMotorSliding();
var grounded : boolean = true;
var groundNormal : Vector3 = Vector3.zero;
private var lastGroundNormal : Vector3 = Vector3.zero;
private var tr : Transform;
private var controller : CharacterController;
function Awake () {
controller = GetComponent (CharacterController);
tr = transform;
}
private function UpdateFunction () {
// We copy the actual velocity into a temporary variable that we can manipulate.
var velocity : Vector3 = movement.velocity;
// Update velocity based on input
velocity = ApplyInputVelocityChange(velocity);
// Apply gravity and jumping force
velocity = ApplyGravityAndJumping (velocity);

// Moving platform support
var moveDistance : Vector3 = Vector3.zero;
if (MoveWithPlatform()) {
var newGlobalPoint : Vector3 =
movingPlatform.activePlatform.TransformPoint(movingPlatform.activeLocalPoint);
moveDistance = (newGlobalPoint - movingPlatform.activeGlobalPoint);
if (moveDistance != Vector3.zero)
controller.Move(moveDistance);
// Support moving platform rotation as well:
var newGlobalRotation : Quaternion = movingPlatform.activePlatform.rotation *
movingPlatform.activeLocalRotation;
var rotationDiff : Quaternion = newGlobalRotation *
Quaternion.Inverse(movingPlatform.activeGlobalRotation);
var yRotation = rotationDiff.eulerAngles.y;
if (yRotation != 0) {
// Prevent rotation of the local up vector
tr.Rotate(0, yRotation, 0);
}
}
// Save lastPosition for velocity calculation.
var lastPosition : Vector3 = tr.position;
// We always want the movement to be framerate independent. Multiplying by Time.deltaTime does this.
var currentMovementOffset : Vector3 = velocity * Time.deltaTime;
// Find out how much we need to push towards the ground to avoid loosing grouning
// when walking down a step or over a sharp change in slope.
var pushDownOffset : float = Mathf.Max(controller.stepOffset, Vector3(currentMovementOffset.x, 0,
currentMovementOffset.z).magnitude);
if (grounded)
currentMovementOffset -= pushDownOffset * Vector3.up;

// Reset variables that will be set by collision function
movingPlatform.hitPlatform = null;
groundNormal = Vector3.zero;
// Move our character!
movement.collisionFlags = controller.Move (currentMovementOffset);
movement.lastHitPoint = movement.hitPoint;
lastGroundNormal = groundNormal;
if (movingPlatform.enabled && movingPlatform.activePlatform != movingPlatform.hitPlatform) {
if (movingPlatform.hitPlatform != null) {
movingPlatform.activePlatform = movingPlatform.hitPlatform;
movingPlatform.lastMatrix = movingPlatform.hitPlatform.localToWorldMatrix;
movingPlatform.newPlatform = true;
}
}
// Calculate the velocity based on the current and previous position.
// This means our velocity will only be the amount the character actually moved as a res ult of collisions.
var oldHVelocity : Vector3 = new Vector3(velocity.x, 0, velocity.z);
movement.velocity = (tr.position - lastPosition) / Time.deltaTime;
var newHVelocity : Vector3 = new Vector3(movement.velocity.x, 0, movement.velocity.z);
// The CharacterController can be moved in unwanted directions when colliding with things.
// We want to prevent this from influencing the recorded velocity.
if (oldHVelocity == Vector3.zero) {
movement.velocity = new Vector3(0, movement.velocity.y, 0);
}
else {
var projectedNewVelocity : float = Vector3.Dot(newHVelocity, oldHVelocity) /
oldHVelocity.sqrMagnitude;

movement.velocity = oldHVelocity * Mathf.Clamp01(projectedNewVelocity) +
movement.velocity.y * Vector3.up;
}
if (movement.velocity.y < velocity.y - 0.001) {
if (movement.velocity.y < 0) {
// Something is forcing the CharacterController down faster than it should.
// Ignore this
movement.velocity.y = velocity.y;
}
else {
// The upwards movement of the CharacterController has been blocked.
// This is treated like a ceiling collision - stop further jumping here.
jumping.holdingJumpButton = false;
}
}
// We were grounded but just loosed grounding
if (grounded && !IsGroundedTest()) {
grounded = false;
// Apply inertia from platform
if (movingPlatform.enabled &&
(movingPlatform.movementTransfer == MovementTransferOnJump.InitTransfer ||
movingPlatform.movementTransfer == MovementTransferOnJump.PermaTransfer)
) {
movement.frameVelocity = movingPlatform.platformVelocity;
movement.velocity += movingPlatform.platformVelocity;
}
SendMessage("OnFall",SendMessageOptions.DontRequireReceiver);
// We pushed the character down to ensure it would stay on the ground if there was any.
// But there wasn't so now we cancel the downwards offset to make the fall smoother.
tr.position += pushDownOffset * Vector3.up; }}

BeeT 3D documentation

Recomendados

Recomendados

Mais conteúdo relacionado

Semelhante a BeeT 3D documentation

Semelhante a BeeT 3D documentation (20)

BeeT 3D documentation