beet 3d documentation

Beet 3DA 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 TWOLITERATURE 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 Related Works (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 Related Works/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 Theoretical Framework

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 PROPOSED SYSTEM

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) FUNCTIONAL REQUIREMENTS

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) NONFUNCTIONAL REQUIREMENTS

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 first chapter of this project introduced the aim of this project, problems with currently used engines

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 chapter summarizes the project with recommendations 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 vector from 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 vector and 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;



// 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 together with 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;



// 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 result 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

Documents