Purdue University

Purdue e-Pubs
Open Access Theses Theses and Dissertations

Spring 2015

Teaching introductory game development with

unreal engine: Challenges, strategies, and
experiences
Nicholas A. Head
Purdue University

Follow this and additional works at: https://docs.lib.purdue.edu/open_access_theses

Part of the Science and Mathematics Education Commons

Recommended Citation
Head, Nicholas A., "Teaching introductory game development with unreal engine: Challenges, strategies, and experiences" (2015).
Open Access Theses. 506.
https://docs.lib.purdue.edu/open_access_theses/506

This document has been made available through Purdue e-Pubs, a service of the Purdue University Libraries. Please contact [email protected] for
additional information.
 Graduate School Form 30
Updated 1/15/2015

PURDUE UNIVERSITY
GRADUATE SCHOOL
Thesis/Dissertation Acceptance

This is to certify that the thesis/dissertation prepared

By Nicholas Head

Entitled
TEACHING INTRODUCTORY GAME DEVELOPMENT WITH UNREAL ENGINE: CHALLENGES, STRATEGIES, AND
EXPERIENCES

For the degree of Master of Science

Is approved by the final examining committee:

David Whittinghill
Chair

Sean Brophy

Esteban Garcia

To the best of my knowledge and as understood by the student in the Thesis/Dissertation

Agreement, Publication Delay, and Certification Disclaimer (Graduate School Form 32),
this thesis/dissertation adheres to the provisions of Purdue University’s “Policy of
Integrity in Research” and the use of copyright material.

Approved by Major Professor(s): David Whittinghill

Approved by: Mihaela Vorvoreanu 4/21/2015

Head of the Departmental Graduate Program Date

 i

TEACHING INTRODUCTORY GAME DEVELOPMENT WITH UNREAL ENGINE:

CHALLENGES, STRATEGIES, AND EXPERIENCES

A Thesis

Submitted to the Faculty

of

Purdue University

by

Nicholas A. Head

In Partial Fulfillment of the

Requirements for the Degree

of

Master of Science

May 2015

Purdue University

West Lafayette, Indiana

 ii

TABLE OF CONTENTS

Page
LIST OF TABLES ............................................................................................................. iv
LIST OF FIGURES ........................................................................................................... vi
ABSTRACT..................................................................................................................... viii
CHAPTER 1. INTRODUCTION .................................................................................... 1
1.1 Research Question ..................................................................................................... 1
1.2 Statement of Purpose ................................................................................................. 2
1.3 Scope ......................................................................................................................... 2
1.4 Significance ............................................................................................................... 2
1.5 Assumptions .............................................................................................................. 3
1.6 Limitations ................................................................................................................ 4
1.7 Delimitations ............................................................................................................. 4
1.8 Definition .................................................................................................................. 4
1.9 Summary ................................................................................................................... 5
CHAPTER 2. LITERATURE REVIEW ......................................................................... 6
2.1 Background ............................................................................................................... 6
2.2 Literature Review ...................................................................................................... 9
2.2.1 Problem Based Learning.................................................................................. 9
2.2.2 Game Development Courses ......................................................................... 10
2.3 Summary ................................................................................................................. 15
CHAPTER 3. METHODOLOGY.................................................................................. 16
3.1 Participants .............................................................................................................. 16
3.2 Course Structure ...................................................................................................... 16
3.2.1 Lecture ........................................................................................................... 17
 iii

Page
3.2.2 Exercises ........................................................................................................ 18
3.2.3 Team Project .................................................................................................. 28
3.3 Experimental Design ............................................................................................... 28
3.4 Hypothesis ............................................................................................................... 29
3.5 Analysis ................................................................................................................... 30
3.6 Summary ................................................................................................................. 30
CHAPTER 4. RESULTS ............................................................................................... 31
4.1 Participants .............................................................................................................. 31
4.2 Results ..................................................................................................................... 34
4.2.1 Prior Experience ............................................................................................ 34
4.2.2 Exercise Performance .................................................................................... 36
4.2.3 Team Project Performance ............................................................................ 39
4.2.4 Course Format ............................................................................................... 45
4.2.5 Course Performance....................................................................................... 48
4.3 Discussion ............................................................................................................... 54
4.4 Recommendations ................................................................................................... 57
4.5 Future Work ............................................................................................................ 61
4.6 Conclusion ............................................................................................................... 61
LIST OF REFERENCES .................................................................................................. 63
APPENDICES
Appendix A IRB Approval Letter .................................................................................. 66
Appendix B Survey ........................................................................................................ 67
Appendix C Exercises .................................................................................................... 96
 iv

LIST OF TABLES

Table ..............................................................................................................................Page
3.1 Final Exercise Plan ..................................................................................................... 26
4.1 CGT 241 Usefulness Data Part 1 ................................................................................ 34
4.2 CGT 241 Usefulness Data Part 2 ................................................................................ 34
4.3 CGT 215 Usefulness Data Part 1 ................................................................................ 35
4.4 CGT 215 Usefulness Data Part 2 ................................................................................ 35
4.5 Exercise Difficulty Data Part 1 ................................................................................... 36
4.6 Exercise Difficulty Data Part 2 ................................................................................... 36
4.7 Team Project Performance Data Part 1 ....................................................................... 39
4.8 Team Project Performance Data Part 2 ....................................................................... 39
4.9 Milestone Usefulness Data Part 1 ............................................................................... 40
4.10 Milestone Usefulness Data Part 2 ............................................................................. 40
4.11 Team Project Contribution Data Part 1 ..................................................................... 41
4.12 Team Project Contribution Data Part 2..................................................................... 41
4.13 Team Project Perference Data Part 1 ........................................................................ 43
4.14 Team Project Perference Data Part 2 ........................................................................ 43
4.15 Exercise Team Project Data Part 1 ........................................................................... 43
4.16 Exercise Team Project Data Part 2 ........................................................................... 44
4.17 Class Format Data Part 1 .......................................................................................... 46
4.18 Class Format Data Part 2 .......................................................................................... 46
4.19 Game Development Confidence Data Part 1 ............................................................ 48
4.20 Game Development Confidence Data Part 2 ............................................................ 48
4.21 Unreal Engine Confidence Data Part 1 ..................................................................... 49
4.22 Unreal Engine Confidence Data Part 2 ..................................................................... 49
 v

Table ..............................................................................................................................Page
4.23 Game Development Aspiration Data Part 1.............................................................. 50
4.24 Game Development Aspiration Data Part 2.............................................................. 50
4.25 Overall Experience Data Part 1................................................................................. 52
4.26 Overall Experience Data Part 2................................................................................. 52
4.27 Instructor Performance Data Part 1........................................................................... 53
4.28 Instructor Performance Data Part 2........................................................................... 53
 vi

LIST OF FIGURES

Figure .............................................................................................................................Page
3.1 Exercise 00 Start ......................................................................................................... 18
3.2 Exercise 01 FPS Controller......................................................................................... 19
3.3 Exercise 02 Landscape ................................................................................................ 20
3.4 Exercise 03 FPS Mesh ................................................................................................ 20
3.5 Exercise 04 House 1.................................................................................................... 21
3.6 Exercise 05 House 2.................................................................................................... 21
3.7 Exercise 06 House 3.................................................................................................... 22
3.8 Exercise 07 Battery ..................................................................................................... 22
3.9 Exercise 08 Target Range ........................................................................................... 23
3.10 Exercise 09 Projectiles .............................................................................................. 23
3.11 Exercise 10 Particles ................................................................................................. 24
3.12 Exercise 11 Main Menu ............................................................................................ 25
3.13 Exercise 12 Polish ..................................................................................................... 25
4.1 Participants Gender ..................................................................................................... 32
4.2 Participants Academic Year ........................................................................................ 32
4.3 Participants Major ....................................................................................................... 33
4.4 CGT 241 Usefulnes Chart ........................................................................................... 34
4.5 CGT 215 Usefulnes Chart ........................................................................................... 35
4.6 Exercise Difficulty Chart ............................................................................................ 36
4.7 Easiest Exercise Chart................................................................................................. 37
4.8 Hardest Exercise Chart ............................................................................................... 38
4.9 Team Project Performance Chart ................................................................................ 39
4.10 Milestone Usefulness Chart ...................................................................................... 40
 vii

Figure .............................................................................................................................Page
4.11 Team Project Contribution Chart .............................................................................. 41
4.12 Team Project Issues Chart ........................................................................................ 42
4.13 Team Project Preference Chart ................................................................................. 42
4.14 Exercise and Team Project Chart .............................................................................. 43
4.15 Engine Preference Chart ........................................................................................... 45
4.16 Class Format Chart ................................................................................................... 46
4.17 Course Distribution Chart ......................................................................................... 47
4.18 Game Development Confidence Chart ..................................................................... 48
4.19 Unreal Engine Confidence Chart .............................................................................. 49
4.20 Game Development Aspiration Chart ....................................................................... 50
4.21 Interest in Advance Course Chart ............................................................................. 51
4.22 Overall Experience Chart .......................................................................................... 51
4.23 Student Grade Chart .................................................................................................. 52
4.24 Instructor Performance Chart .................................................................................... 53
4.25 Recommended Curriculum ....................................................................................... 58
 viii

ABSTRACT

Head, Nicholas A. M.S., Purdue University, May 2015. Teaching Introductory Game
Development with Unreal Engine: Challenges, Strategies, and Experiences. Major
Professor: David Whittinghill.

From the days of Pong to 100 million dollar projects such as the Grand Theft Auto

franchise, video games have evolved significantly over the years. This evolution has also

changed the way game development is viewed as a career. Today, video games are one of

the most profitable forms of entertainment, and game development courses are appearing

at universities around the world. Even with this growth, a degree from a university has

yet to be an important factor in finding a job in game development (Owen, 2013). This

thesis examines a method of creating and implementing an introductory gaming course

and recommends ways to improve the curriculum.

The main focus of the course was to introduce game development to the students.

Each week, they were given an exercise that covered a different topic. Students also took

part in a team project in which they were tasked with creating a complete game. The goal

of the team projects was to expand the student’s basic knowledge given to them from the

exercises. Data was gathered on the students’ subjective experiences with the class. This

data and the class’s overall performance were compared with past iterations of the course.

New to the course was the Unreal Engine. Students used the latest version of the engine,

Unreal Engine 4, to complete exercises. Not all students chose to use this engine for the
 ix

team project. Instructor and students experiences with the engine were also recorded.

While there were some problems implementing the engine within our lab environment,

we were still able to execute the overall lesson plan. Even with the engine issues, the

course had overall good performance. CGT 241, Introduction to 3D Animation, was

shown to help the students to complete the course while CGT 215, Computer Graphics

Programming I, did not provide enough information on game programming. Exercises

were found to be helpful but students wanted a better understanding of how these skills

can be applied to game development. Team projects also went well with most teams

creating a functional project. Students wanted more time to complete projects along with

a structured approach to the project. Confidence in game development and the Unreal

Engine were not high but students were enthusiastic in continuing in the field of game

development.

Recommendations were made to the curriculum in order to fix some of the issues

with the introductory course and help students find a career. In order to fix the gap

between the programming course and the introductory game course, a video game

programming course was recommended that focused on teaching students how code

works with video game engines. An option to specialize was also recommended in order

to see a higher level of understanding on game concepts and a higher level of quality of

game projects. Changes to the higher courses were also made for a yearlong course where

students would focus on a single project to publish. This would expand on the

introductory course while also replicating the game development process.

 1

CHAPTER 1. INTRODUCTION

The goal of the Computer Graphics Technology (CGT) department at Purdue

University is to give students the tools to turn ideas into models, digital animations,

interactive games, and other disciplines (Computer Graphics Technology, n.d.). At the

time of publication, video game courses had been growing steadily in the department for

the past several years. The curriculum had grown from a single application development

course to Introduction to Game Development, CGT 345, and an advanced course, CGT

445. CGT 345 builds upon concepts from the department’s introductory 3D animation

courses as well as the programming courses while CGT 445 builds upon CGT 345 with

advanced topics such as path finding, artificial intelligence (AI), and game psychology.

This paper focuses on the implementation and assessment of the introductory course,

CGT 345.

1.1 Research Question

Is CGT 345 successful in teaching the basic skills needed to advance to the next

level of game development?

 2

1.2 Statement of Purpose

This thesis evaluates previous and current attempts to teaching introductory game

development to undergraduate students. Previous courses have discussed the teaching

process of art, programming, and design for game development. The current course’s

goal is to teach students the basics skills to continue in game development. These skills

are a basic understanding of programming, art, and design. This implementation is

examined through the instructor and student points of view.

1.3 Scope

This research focuses solely on the introductory game development course at

Purdue University. The research assesses the overall performance of the course from the

students’ and instructor’s perspective. Student data were collected using a post survey

that explored their experiences in the course. A comparison with the student data was

made from the instructor’s opinion of the course. Overall, the goal was to see if the

course was successful in teaching students the basic skills to advance in game

development.

1.4 Significance

Game development courses are a young curriculum that is just starting to take form

around the world. It has grown greatly from its computer science origins to be taught

from within a variety of disciplines. However, the core components for teaching game

development at the college level remain a moving target. Even after completing these

courses, a degree in game development has yet to become a standard in the video game
 3

industry. According to recent data, on average a student with only a high school diploma

earns more than a student with a bachelor’s degree (Graft, 2014). Students are sometimes

not even taught industry standard techniques in college courses. This knowledge gap

makes it harder to find a game development job and can lead to a large amount of on-the-

job training. Game development jobs have been found to place a high emphasis on skills

rather than education (McGill, 2008). In personal correspondence, even the author has

been told by professional game developers that college is “a waste of time” in the

industry. There is a need to improve the current system of teaching students in order to

better prepare students for a career in game development. By improving this system,

students will be more likely to find jobs and create better games thanks to the skills

taught to them at a university.

1.5 Assumptions

This research was performed and conclusions have been drawn using the following

assumptions:

• Participants are either enrolled or instructing the introductory course.

• Participants completed the preparatory coursework

• Participants answered all questions of the survey truthfully

• Courses evaluated were related to art, programming, or design principles of game

development
 4

1.6 Limitations

This research was limited by the following:

• Subjects were limited to students that enrolled in the Fall 2014 CGT 345

introductory game development course at Purdue University.

• Reviewed only the introductory game development course at Purdue

University.

• Did not review game development courses relating to business or human

resources.

1.7 Delimitations

This research was performed acknowledging the following delimitations:

• The survey analyzed the overall performance of the student in the course.

• All participants were over the age of 18.

1.8 Definition

AAA Game: Generally a title developed by a large studio or funded by a large budget

(Schultz, n.d.).

Game Development: the process of creating video games.

Normal: An outward directional vector that is perpendicular to the surface of a three-

dimensional model (Slick, n.d.).

Unreal Engine: A video game engine created by Epic Games.

UV: A two-dimensional plane that represents vertices on a three-dimensional object

(Slick, n.d.).
 5

Video Game Engine: a tool that brings together art, programming, and design with the

goal of creating a video game (Ward, 2008).

WASD: the computer keyboard keys W, A, S, and D.

1.9 Summary

This chapter introduced the key concepts by going over the purpose, scope, and

significance of the study. It also reviewed the assumptions, limitations, and definitions.

Chapter will evaluate previous attempts and methods of teaching video game courses.
 6

CHAPTER 2. LITERATURE REVIEW

Chapter 2 reviews game development courses in order to understand how these

courses are taught. Understanding the history will reveal what works and where there is

room for improvement.

2.1 Background

CGT 345 has gone through different forms and names. The course started as CGT

245 and it focused on mobile application development using Corona SDK. This engine

allowed students to develop applications or games for the course. This was before the

game development focus had grown so students were generally from the web application

field. Similar to the present class, students would complete exercises every week and

along a team project. In contrast to the present class, there was also an overall class

project where the entire class would coordinate together to create a game. This class wide

project was hard to implement and gave students a large amount of work for a single

course. The course shifted away from mobile development in 2011 in favor of a studio

environment using Unity 3D.

At the time, Unity 3D was a new game engine that was quickly gaining favor with

independent developers and smaller studios. It was similar enough to other major 3D

engines that it allowed students to create high level projects while it also allowed them to
 7

carry over basic game development principles to other engines. Also, students had access

to a free version of Unity 3D that could be installed on their personal computers. A

problem arose with this change as some students were unable to complete the modeling

exercise. Students used Autodesk Maya, a 3D modeling software, to create a house along

with other game objects. The problem was that students had either yet to take the 3D

animation course, CGT 241, or they were of another discipline, such as web development.

To combat this, the exercise was split into three parts and students were given a step by

step tutorial on modeling, unwrapping, and texturing the house. In the end, these changes

did not alleviate the problem as students still did not have the basic modeling knowledge

needed to complete the exercises. The course was then changed to CGT 345 and the

modeling course was added as a prerequisite. One of the outcomes this paper will observe

is whether these problems are still occurring in the current course model.

CGT 241 is a survey course for animation. The goal of the course is to prepare

students for further study in higher level topics of 3D animation. Course work consists of

modeling, animating, texturing, rendering, lighting, and rigging 3D objects. While the

class teaches a variety of topics, it gives students enough experience in modeling to

create basic shapes or structures. One thing the class does not cover is implementing

assets into a video game engine. Certain steps and procedures are different when creating

models for a video game in contrast to a 3D animation. However, the modeling

differences for the introductory game development course are minor enough to be shown

in a demonstration. Currently, if a student was to improve on modeling aspects in the

game development field, they need to do this outside of the curriculum.

 8

Another prerequisite is CGT 215, Computer Graphics Programming I. This course

focuses on scripting and programming fundamentals, logic, and problem solving. It also

provides the basis for developing object-oriented applications by understanding how to

write, compile, build, and debug an application. All of this has provided students with

enough programming knowledge to complete the exercises in CGT 345 in the past. The

course also uses C++ as the main programming language, which is the same coding

language as Unreal Engine (unlike Unity that uses C#). The goal of this prerequisite is to

prepare students for the programming tasks that they face in the introductory course.

The Unreal Engine has been used by many developers as a basis to turn ideas into

games. Titles such as Mass Effect, Gears of War, Bioshock, and many other successful

franchises have used this engine to create engaging and dazzling experiences (Unreal

Engine 3, n.d.). In the past, Epic Games, the creator of the Unreal Engine, had made a

free version of the engine, known as Unreal Development Kit. It featured a similar

interface as Unreal 3 but without some of its major features. In order to get these features,

a license would need to be purchased, which could cost upwards of a million of dollars

for developers and educators. This steep price gap was one of the reasons that made the

Unity 3D engine appealing. The Unreal Engine 4 changed this with the introduction of a

subscription based model, $19.95 a month, which offered all of its features with Unreal

Engine 4 and could be installed on any number of the lab computers. In contrast, a license

was needed for every computer that Unity was installed. If the subscription was canceled,

then the owner would still be able to use the version of the engine they owned before the

cancellation. Students would only need to pay one payment in order to download the

engine for the course. However, they would not be able to update the engine without a
 9

subscription. Also, if the student was going to sell a game they created using the engine,

they would need to pay for a subscription and give 5% of the profits to Epic Games. Not

only is this a better solution for the department but it also gives students experience with

an industry standard engine that can improve their chances of finding an industry job

after college.

2.2 Literature Review

This section discusses an approach that will be used to teach the current

introductory game development course while also exploring how other programs have

implemented their game development courses.

2.2.1 Problem Based Learning

The course was developed around a problem based learning method. Problem

based learning is a teaching method that combines the acquisition of knowledge with the

development of generic skills (Wood, 2008). Graff and Kolmos (2007) also define it as a

method to organize the learning process in a manner that the students are actively

engaged in finding the solution. This method started in the 1960’s among medical

educators that were striving to provide an education in professional practices by engaging

students with real problems that doctors encountered (Pease & Kuhn, 2011). Since then,

the process has been evolving to affect the education of scientific fields and even game

development.

BMU, Belgrade Metropolitan University, used a problem based learning method

for their game development course (Timcenko & Stojic, 2012). The later version of the
 10

course even features Autodesk Maya for modelling and the Unity 3D game engine.

Similar to CGT 345, students would learn core techniques with a traditional teaching

model but also be assigned group problem solving exercises and projects. Instructors

would help out with these group assignments but only as an advisor. This thesis differs in

that its uses a lab oriented course with students that are less experienced in creating

games.

Another example had a sixth grade class work on a sustainable game project

(Hwang, Hung, & Chen, 2013). Students would work on a game for 50 minutes a week

over a 10 week period to promote a pollution free town. Teachers did not tell the students

how to achieve this goal as they just advised and gave guidelines for the project. Instead,

students would evaluate each other’s work and assess the quality of the project. The data

showed that this approach improved students learning achievements, motivation, and

problem solving skills in comparison to the conventional game approach. While the

researcher will be using a college level course with students creating their own assets,

this thesis illustrates the importance of the problem based learning method when used to

develop games.

2.2.2 Game Development Courses

Gaming courses have been used for a variety of reasons at the university level. A

large amount of these programs started in the Computer Science department. Video

games have been used to draw attention and gain applicants for the department. One

university tried to create a game based programming course using XNA (Sung,

Rosenberg, Panitz, & Anderson, 2008). XNA is a game engine that allows students to
 11

create a console game, Xbox 360, using the C# programming language. Similar to Unreal,

XNA is able to handle 2D and 3D objects. However the class only focused on

programming, which led them to a 2D approach. In contrast, this paper focuses on a

general approach to accommodate for both artistic and mathematically minded students.

The program experienced problems adjusting the difficulty of the course due to some

assignments and technical issues. The goal of the course was not teach the basics of game

development but rather to introduce students to the computer science program.

Another CS course also evaluated its effectiveness in keeping students using

game development courses. They found that they were capable of keeping a 93%

retention rate through this game development course (Bayliss, 2009). However, students

were not able to explore and create their own game until later into the game development

program. The paper did highlight the need for some creativity in the class to keep

students interested and it highlighted problems such as program issues and time

constraints that were also observed in the application of the introductory game

development course.

Anderson and McLoughlin (2007) tried to create a class using C-Sheep to teach

programming to animation students. The C-Sheep system was a library written in ANSI

C that allowed the user to tweak the environment and characters that were provided.

Instead of teaching the basics of game development, the course was teaching students the

basics of C programming. Along with the different focus, the class was unable to

accommodate a team project to explore the principles that they learned in the course. This

lack of exploration led to students questioning how the system worked without having

instances to try them.

 12

Another way for a program to avoid overloading students with asset creation and

programming is to use Mods. Mods are modifications done to existing games usually

through an editor provided by a developer. One study used Mod’s in a workshop setting

to teach students about game development (El-Nasr & Smith, 2006). The two workshops

catered for a wide variety of disciplines similar to this thesis. The classroom part of the

study used Wildtangent’s Web Driver and Unreal Tournament 2003, which gives

students access to the Unreal Development Kit. With UDK, they were asked to edit a

DeathMatch map using the Unreal Editor, map editor, and Unreal Script. While UDK

gave students a taste of the Unreal Engine, Unreal Engine 4 has all of the high end

development features available to the students. Similar to our introductory course, the

Web Driver exercises gave students step by step instructions on how to create a game.

Another similarity is that students were allowed to complete their final project in

whatever engine that they chose to use.

Wynters (2007) also used Unreal Tournament except with the focus of teaching

non programming principles such as modeling and lighting. Students used modeling

software to create models and terrain for the levels. This course was similar to the

previous iteration of CGT 345 as it had to teach students how to use the modeling

software. CGT 345 has to teach a wider variety of disciplines in comparison to this

papers art perspective. Teaching students only about art would take time out of the other

core concepts of game development that need to be taught before a student can advance

to a higher level course. However, this class was able to teach artistically oriented

students about game development.

 13

One course had mixed disciplines that worked together to create a game project

(Gestwicki, Sun, & Dean, 2008). Programming and design students worked together to

create a single game project over the semester. The first five weeks consisted of the

creation of the design document while the last 10 were developing the game. Unlike our

course, they had milestones every three weeks instead of every week. They also started

around three weeks before our students created their groups. In this course, design

students seemed to only be doing conceptual work while the programming students

implemented the entire game. In our course, students will still get to experience the

different disciplines of game development while also learning a new engine.

The University of Santa Cruz used Game Maker to teach a large number of

students, 172 students, about game design (Whitehead, 2008). Game Maker is a 2D game

engine that comes with its own built in scripts. Unlike Game Maker, Unreal is able to

support both 2D and 3D game projects with the use of outside code. The course features a

similar capstone or final project as this paper but the class focuses more on game analysis.

Students would analyze and come up with game ideas by playing video games. While it

is an interesting concept, it strays away from teaching students the basics of development

in order to create a game. At Purdue, students do not dwell into the game design process

until they understand how a game is created. While the students learn important skills

regarding game design, they do not gain the technical skills needed in order to understand

how video games are created.

DePaul University’s introductory course also uses Game Maker but their

advanced class uses XNA (Linhoff & Settle, 2008). Their course is very similar to Purdue

in that students complete exercises and a team project throughout their time in the course.
 14

However, this course design is implemented mostly at the advanced level instead of the

introductory level as seen with CGT 345.

Another study used Metaio Creator to teach students about augmented reality

(Wichrowski, 2013). This project mixed art and computer science students together

similar to the CGT 345. Classes consisted of multiple projects that focused on a different

topic or theme. The art students had a hard time working with the editor but were

eventually able to adapt while computer science students had an easier time with the class.

In contrast, our course covers both art and programming subjects that align with the two

disciplines. Also, past history had the art exercises being the most difficult to complete

instead of the programming exercises.

Dondlinger and Wilson (2012) created an alternate reality gaming course that

focused on a learn and apply approach. The course uses a similar approach to our course

in that students are given basic lessons to learn about the application of the technology

but the main learning component of the course was solving a problem or applying the

solution to a project. One problem with this strategy was that the core learning concepts

were not established. The paper blames most of this on the class structure and the late

introduction of the game. Our course will need to avoid these problems by introducing

the course project at the correct time. However, this course focuses on alternate reality

gaming where user’s physical actions are more important than the digital interface. Also,

they had a smaller class size, six students, participate in the course.
 15

2.3 Summary

This chapter discussed the history of game development courses and how they

compare to the current implementation of the introductory game development course at

Purdue University.
 16

CHAPTER 3. METHODOLOGY

This chapter discusses the implementation of the game development course and

how it was evaluated. The goal of this research is to study student impressions and course

performance in order to make suggestions for future courses.

3.1 Participants

Students and instructors that took part of the fall 2014 CGT 345 course at Purdue

University were used as the subjects for the study. The course started with 21 students

and ended with 19 actively participating in the course. These 19 students were over the

age of 18 and were given an optional survey to complete at the end of the course. Surveys

were distributed through the course email list and were completed without the instructor

present. Instructors kept a log of the course that described issues and observations about

the course.

3.2 Course Structure

The course used a lab orientation throughout the semester. Class took place inside

a computer lab for two hours every Monday and Wednesday. The beginning of class was

used for some lecture and demonstration while the rest of the time allowed students to

complete assignments and ask questions. Each week students were assigned an exercise
 17

that explored a different aspect of game development. Students were also given a team

project near the middle of the semester to complete.

3.2.1 Lecture

Lectures consisted of demonstrations that would go over that week’s exercise.

Every Monday a new exercise was introduced by showing students how the completed

exercise would function. Depending on the exercise, a demonstration of concepts or

components would be shown to the students.

As a demonstration for Exercise 00, students were shown how to navigate through

the Unreal editor. This started with showing students how to create a project. Next, a

quick overview was done of the different functions of the windows within the editor. This

ranged from discussing how to move within the level editor to how certain windows

described what was happening within the editor. Students were then given the rest of the

class time to experiment with the editor and ask questions.

The demonstration for Exercise 02 highlighted the different tools of the landscape

editor. Students were shown how to set up a landscape by creating a material and using

particular editor settings. Examples were then shown of the different tools that could be

used to change the topography of the landscape.

To combat issues seen in previous iterations of the course, a demonstration was

given for Exercise 04 that showed what not to do when modeling a house. Students

received an explanation of examples with improper UV’s and normal’s. They were then

shown a correct house and how it differed from the incomplete examples.
 18

Due to the lab oriented style of the course, there were few lectures as the course

had an emphasis on students’ exploration and asking questions. Students would be

introduced to their work but a greater importance was placed on exploring the editor and

having one-on-one discussions with the instructor. This gave them time to understand

how to create games before discussing how to create a good game.

3.2.2 Exercises

Every week, students were given an exercise to complete. Each exercise built

upon the previous one until a completed game was created. These finished projects

featured similar objectives with small aesthetic changes.

Figure 3.1 Exercise 00 Start

Exercise 00, Figure 3.1, was an introduction to the Unreal Engine with the goal of

teaching students about Unreal’s scalability settings and how to package a project.

Students opened up the editor and used the Third Person Blueprint Template as the basis

for the assignment. The Unreal Editor featured ways to edit scalability settings while in

the editor. These settings affect properties such as view distance, shadows, or other

render properties. Changing these settings allowed the game to run smoother on slower

machines. When a project was turned into an executable format, Unreal calls this

packaging, the scalability settings do not transfer over. To fix this, students were given a
 19

guide to add these settings to a built project. The finished exercise was a packaged project

with some type of engine scalability applied.

Figure 3.2 Exercise 01 FPS Controller

In the next exercise, shown in Figure 3.2, students created a first person controller.

This controller used the WASD keyboard keys and the mouse to move around the level.

The controller was also able to jump with the space bar by utilizing Unreal’s input

mapping and C++. Due to unforeseen lab issues, some students were unable to complete

the exercise until a later date. The students that were able to complete this assignment had

a home computer that was able to run Unreal Engine. In order to include the other

students, a Blueprint version of the assignment was created. Blueprint is a node-based

programming tool that comes with the Unreal Engine. It replaced the previous node-

based programming tool in Unreal 3 called Kismet. These lab exercises contained the

same content as the original but without the C++ programming. Another feature that

students experienced was how to use the Game Mode class. This feature sets certain

universal values that would affect how the game would be played. The goal of the

exercise was to introduce students to the different programming methods within Unreal

by also introducing them to the concept of character controllers. In the end, students had
 20

a working controller that would allow them to move and eventually interact with the

objects.

Figure 3.3 Exercise 02 Landscape

Exercise 02 focused on creating a landscape to explore. Students were introduced

to the material editor where they would create the layers in order to paint details onto the

blank terrain. Next, they used the landscape editor to create a landscape. The editor

allowed them to change the height and composition of the landscapes. Grass was also

placed using the foliage tool. A grass mesh was provided for the students. Finally they

followed a tutorial to create a basic water effect for an ocean. Students were shown how

to utilize the material editor and edit the terrain using the landscape tool. The end product

was an island, shown in Figure 3.3, that can be explored using the player controller from

the previous assignment.

Figure 3.4 Exercise 03 FPS Mesh

 21

Students added a mesh to the character controller in exercise 03. This made it

similar to a FPS controller used in AAA games such as Call of Duty except without the

aim assist. They added a character mesh that would be invisible to the player camera and

an arm mesh that would only be visible to the player camera. Also, students learned about

applying and sequencing animations for the meshes. The goal of this exercise was to

show students how to utilize meshes with an animation in the engine. With this, the major

functions for the character controller were completed.

Figure 3.5 Exercise 04 House 1

Figure 3.6 Exercise 05 House 2

 22

Figure 3.7 Exercise 06 House 3

The next three exercises contained the modeling problems experienced in

previous iterations of the course. Exercise 04, Figure 3.5, had students create a house

model along with other household objects. By expanding on the CGT 241 work, students

learned about how normal’s and UV’s affect the light maps of models in the Unreal

Editor. Next, students made aesthetic changes to the models by adding textures and lights

in exercise 05, Figure 3.6. Finally, they added collisions to the house and an open door

sequence using Blueprint in exercise 06, Figure 3.7. The end goal for these three

exercises was for students to understand how to create, implement, and interact with

models within the Unreal Engine. Together, students completed a house door that would

open and close depending on the controller’s proximity.

Figure 3.8 Exercise 07 Battery

 23

Exercise 07 introduced students to Unreal’s HUD (Heads-Up Display) elements.

First they created a battery mesh to spawn along with an image representing the different

power levels. Students learned how to randomly spawn objects within an area and how to

collect them. They then used the HUD Blueprint to inform the player of the number of

batteries they had collected. The house Blueprint was changed to only open when the

character has collected all of the batteries. This exercise taught students how to create a

HUD and communicate between different programming scripts. In the end, the character

collected randomly spawning batteries to open the door of the house, Figure 3.8.

Figure 3.9 Exercise 08 Target Range

Figure 3.10 Exercise 09 Projectiles

Next, students were tasked with creating a target range, three targets, and a

coconut for Exercise 08, Figure 3.9. This included texturing the models of the different
 24

objects. These objects were used in Exercise 09 where the character controller was able

to fire a projectile, which was a coconut. They fired the coconut to try and knock down

all of the targets in order to gain another battery. These exercises taught students about

collisions and how to apply basic game logic. The completed projects have an interactive

shack that rewards the player for completing the shooting range, Figure 3.10.

Figure 3.11 Exercise 10 Particles

Exercise 10 has the character collect a match, one of the other models created in

Exercise 04, in order to light a fire, Figure 3.11. Students experimented with Unreal’s

Cascade to create a fire particle effect. There were some problems implementing this

exercise. The final student version appeared different then the intended result. This could

be due to the changes in the exercises or due to new engine settings. Originally, students

were going to learn how to migrate assets between projects. This was too much for the

students to handle with all the changes so this part of the exercise was cut. Even with this

issue, students learned how to create and edit the particle system. In the end, the player

had the ability to activate a particle system that signaled the winning condition of the

game.
 25

Figure 3.12 Exercise 11 Main Menu

In Exercise 11, a main menu was added to the project, as shown in Figure 3.12.

This exercise expanded on the HUD lesson from Exercise 07 by allowing students to

create clickable buttons. The menu allowed the player to play the game, give instructions,

and quit the game. Students were taught about some of the shortcomings of the Blueprint

editor. One of the problems is that a new line command does not work in Blueprint. This

means that it will be difficult to write paragraphs of text for their games. By completing

this exercise, students understood how to create a working menu that can take them to the

main game.

Figure 3.13 Exercise 12 Polish

The last exercise, 12, added a loading and win screen to the game. The terrain and

other assets needed to load when going from the main menu to the game. Without the
 26

load screen, the player would notice certain issues with the level. Adding a loading screen

gave the game time to fix the issues and gave the player a smoother experience. This

exercise showed students how to create this screen and a win screen after the player lights

the fire. The goal of the exercise was to show students the logic of screens within games.

All together, the students had a completed project where they transitioned from different

levels to complete objectives in order to win the game.

Table 3.1 Final Exercise Plan

Title Description
Exercise 00: Start Introduction to Unreal
Exercise 01: FPS Controller Character Control and Inputs
Exercise 02: Landscape Landscape tool and Material Editor
Exercise: 03: House 1 Modeling and UV unwrapping a house
Exercise 04: House 2 Texturing House
Exercise 05: Target Range Create a target range
Exercise 06-1: Unity An introduction to the Unity Engine
Exercise 06-2: Landscape Unity Create a Terrain/Landscape using Unity
Exercise 07: FPS Mesh Adding mesh and animation to controller
Exercise 08: House 3 Fire Projectiles to shoot down targets
Exercise 09: Battery Spawn and collect items
Exercise 10: Particles Creating fire using cascade
Exercise 11: Projectile Fire projectiles to shoot down targets
Exercise 12: Main Menu Creating a menu
Exercise 13: Polish Adding a Load and Win screen

There were problems using the Unreal Engine with the lab environment. Due to

the way that the system stored data and how Unreal read files, certain versions of the

project could not run in lab and there were compatibility issues with compiling code in

Visual Studio. Exercises had to be moved into an order that could be completed

successfully in lab until a solution was found. Table 3.1 illustrates the changes to the
 27

schedule and adds a description of the exercises. Unity exercises were added to the class

to try and compensate for the problems.

Exercise 6-1 was an introductory lesson into Unity where the students created a

controller that can shoot and knock down objects. The goal was to understand how Unity

handles objects and code. On the other hand, exercise 6-2 had students create the same

landscape in Unity. This helped to confirm the basics of landscape, or terrain,

development in a game engine. Also, students were given a small sample of the Unity

workflow to compare to Unreal.

In the end, a partial solution was found where settings had to be saved in the

project’s config files as well as converting all of the C++ sections into Blueprint for the

lab computers. This conversion process created two versions of the exercises, home and

lab. The home version of the exercise was close to the original but with a few changes

due to the reordering of the exercises. These were created for students that worked

mainly on their home computers. In contrast, the lab version was created for students that

could only run Unreal in the lab environment. This section implemented the Blueprint

solution instead of relying on Visual Studio. Students still used the same process and

terminology but the home students got to experience the C++ and visual programming

interface while the lab students only experienced the latter.

It was discovered in the next semester that there were some issues with the lab

version of Visual Studio. It was not recognizing certain file directories. To fix this,

students went to the project properties and went to VC++ Directories to set everything to

inherit from parent. This allowed students to compile their code. However, students were

still unable to package projects that had opened Visual Studio. The Config folder issue
 28

was also solved after updating the Unreal Engine to 4.4. This update automatically saved

the changes done to project settings in contrast to the previous versions that were

dependent on the Set as Default button. It was also discovered that Unreal would only

work properly within version 4.4 to 4.6. Anything above or below it did not work

correctly in lab.

3.2.3 Team Project

Near the middle of the semester, students worked together in team projects to

create a game. Teams consisted of 3 to 4 students that decided on the game that they

would create. Students were given the freedom to choose their own engine to use for the

project. The Professor and TA acted as advisors for the project and set up milestones each

week for the student to complete. These milestones were modeled on the publisher and

developer relationship seen in the video game industry. The goal of this project was for

students to explore the engine and to solve the issues they would face while creating a

real game.

3.3 Experimental Design

Students had the option to complete a survey at the end of the semester. This

survey was hosted on Qualtrics and distributed through the course email. No names were

recorded in the survey and the course email does not reveal the names of the students on

the list. Survey completion was not mandatory for the course and the instructor was not

present when they completed the survey.

 29

The main purpose of the survey was to gather a mix of quantitative and qualitative

data on the performance of the course. It asked students their thoughts on certain

components of the course and to explain their thought process. The questions with

quantitative results asked the students to evaluate a positive statement with a seven point

Likert scale from Strongly Agree to Strongly Disagree. A scale of seven was used as it

gave a greater range of responses and it fit well with the survey format. The qualitative

results were open-ended and asked why the student answered in that manner. The

quantitative data created suggestions for future studies while the qualitative results

explained the suggestions. Student grades were also used in the study. These grades were

not identified with the student in anyway and were only be used to judge the overall

performance of the course.

Instructors kept a log that described different problems and observations seen

throughout the semester. These observations were compared with the student’s in order to

account for possible bias from the suggestions.

3.4 Hypothesis

Ho = the course had no effect teaching students basic game development skills to advance

to the next level of game development.

Ha = the course had an effect teaching students basic game development skills to advance

to the next level of game development.

 30

3.5 Analysis

The quantitative data were analyzed using a t-test and confidence interval using

an alpha value of .05. Due to the small sample, any results were seen as a suggestion

rather than significance until future studies are done. Qualitative data from the students

and instructors were analyzed to find common values to describe the experience of the

course.

3.6 Summary

This chapter discussed the methodology by describing the assignments for the

course and how the performance will be evaluated. Also, this illustrated the hypothesis

and participants for the study. The next chapter will go over the results.
 31

CHAPTER 4. RESULTS

This chapter illustrates the results and discusses the findings. Participants needed to

complete every section of the survey except for the last page that contained open-ended

questions. Testing was done using confidence intervals due to the small sample. Any

statistical analysis was taken as a suggestion for future research.

4.1 Participants

A total of 21 students participated in the course. Of these students, 19 actively

participated in the course by completing exercises and team projects. 2 students

completed less than 1% of the course work. 17 students completed the survey while 14

completed the requirements for the study.

 32

Participants
16
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
Male Female

Complete Incomplete

Figure 4.1 Participants’ Gender

At the end of the semester, the course had a total of 19 male and 2 female students.

Of these students, 15 males and 2 females attempted to complete the survey. Two males

and 1 female were unable to meet the completion requirements for the study.

Year
11
10
9
8
7
6
5
4
3
2
1
0
Freshman Sophomore Junior Senior Graduate

Complete Incomplete

Figure 4.2 Participants Academic Year

 33

The participants of the survey were upperclassman. 10 of the participants were

Juniors while 7 were Seniors. 1 of the Juniors and 2 of the Seniors did not complete the

survey.

Major
17
16
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
CGT CIT

Complete Incomplete

Figure 4.3 Participants Major

16 of the participants were from the CGT department while 1 student was from

the Computer Information Technology, CIT, department. The 3 students that did not

complete the survey were from the CGT department.

Participants also self-reported modeling, coding, or game software that they were

familiar with. A majority of students reported having prior skills with the Autodesk Maya

modeling software. Some students also had used other modeling software such as

Blender, 3DS Max, or Catia. There was a trend in programming were students had either

used some type of C coding or Java. A couple students also had some experience with

Unity 3D engine. One student had prior experience using the Unreal Engine before taking

the course. Another student reported having no previous skills before taking the course.
 34

4.2 Results

This section shows the results by splitting them into the categories of prior

experience, exercise performance, team project performance, course format, and course

performance.

4.2.1 Prior Experience

CGT 241

1 2 3 4 5 6 7
Response

Figure 4.4 CGT 241 Usefulness Chart

Table 4.1 CGT 241 Usefulness Data Part 1

Statistic Min Value Max Value Mean Variance
Value 1 7 2.47 2.64
Table 4.2 CGT 241 Usefulness Data Part 2
Statistic Standard Total t-value Confidence
Deviation Responses Interval
Value 1.62 17 -3.894 1.784, 3.156
 35

When asked about the usefulness of CGT 241 for the course, the data shows a

right skew favoring a positive response. Along with the confidence interval of 1.784 and

3.156 not containing the null hypothesis value of 4, this suggests that students felt that

CGT 241 was useful in completing the course.

CGT 215

1 2 3 4 5 6 7
Response

Figure 4.5 CGT 215 Usefulness Chart

Table 4.3 CGT 215 Usefulness Data Part 1

Statistic Min Value Max Value Mean Variance
Value 1 7 3.35 2.87
Table 4.4 CGT 215 Usefulness Data Part 2
Statistic Standard Total t-value Confidence
Deviation Responses Interval
Value 1.69 17 -1.586 2.634, 4.066

Participants were asked about the usefulness of CGT 215 for completing the

course. The data for CGT 215 usefulness has a slight right skew. Responses had a wide

spread making it closer to a normal distribution. Due to the confidence interval

 36

containing the null hypothesis of 4, 2.634 to 4.066, the data suggests that CGT 215 had

no effect in preparing students for the course.

4.2.2 Exercise Performance

Exercise Difficulty

1 2 3 4 5 6 7
Response

Figure 4.6 Exercise Difficulty Chart

Table 4.5 Exercise Difficulty Data Part 1

Statistic Min Value Max Value Mean Variance
Value 2 7 4.5 2.58
Table 4.6 Exercise Difficulty Data Part 2
Statistic Standard Total t-value Confidence
Deviation Responses Interval
Value 1.61 14 1.162 3.738, 5.262

The data regarding the difficulty of the course exercises has a slight left skew. No

one strongly agreed with the statement. Also, the data has a confidence interval of 3.738
 37

to 5.262 that contains the null hypothesis of 4. This suggests that students had a neutral

view on the difficulty of the course exercises.

Easiest Exercise
11
10
9
8
7
6
5
4
3
2
1
0
Art (modeling, texture, etc.) Programming Design

Figure 4.7 Easiest Exercise Chart

Participants felt that the art-oriented exercises were the easiest. They reported that

their past modeling experiences helped them to complete the exercises. Another reason

that participants felt that it was easier was because Maya was working correctly in labs

while Unreal was experiencing some issues with the programming components.
 38

Hardest Exercise
13
12
11
10
9
8
7
6
5
4
3
2
1
0
Art (modeling, texture, etc.) Programming Design

Figure 4.8 Hardest Exercise Chart

Participants felt that the programming exercises were the hardest due to a lack of

experience. They reported that they did not understand the Blueprint interface or how to

use C++ with the Unreal Engine. Again, some participants talked about the lab issues and

how it affected their ability to access code. Participants also felt that CGT 215 did not

prepare them for the course. There was too much of a gap between the introductory

programming and what they needed to accomplish in the course.

When asked which exercise would be the most useful, most participants felt that

the exercises that were oriented towards the art aspect were the most useful. Specifically,

participants enjoyed the terrain and house exercises. They reported that the exercises

allowed them to understand how Unreal handles modeling. One student preferred the

Unity exercises over the Unreal exercises.

In order to improve the exercises, participants wanted a greater amount of images

to be added in the exercise instructions. They felt that they could sometimes get lost
 39

within the large amount of text. Also, they would either prefer more demos or more of an

explanation of the exercises in class.

4.2.3 Team Project Performance

Team Project

1 2 3 4 5 6 7
Response

Figure 4.9 Team Project Performance Chart

Table 4.7 Team Project Performance Data Part 1

Statistic Min Value Max Value Mean Variance
Value 1 5 2.93 1.61
Table 4.8 Team Project Performance Data Part 2
Statistic Standard Total t-value Confidence
Deviation Responses Interval
Value 1.27 14 -3.152 2.323, 3.531

Participants’ data regarding the team project performance has a right skew. It had

a maximum value of 5 – somewhat disagree. The confidence interval was also 2.323 to
 40

3.531 which does not contain the null hypothesis of 4. This suggests that team projects

went well during the course.

Milestone

1 2 3 4 5 6 7
Response

Figure 4.10 Milestone Usefulness Chart

Table 4.9 Milestone Usefulness Data Part 1

Statistic Min Value Max Value Mean Variance
Value 1 6 2.71 1.91
Table 4.10 Milestone Usefulness Data Part 2
Statistic Standard Total t-value Confidence
Deviation Responses Interval
Value 1.38 14 -3.498 2.057, 3.363

When asked about the team project milestone usefulness, the results show a right

skew. The maximum value was a 6 for disagree. This along with the fact that the

confidence interval, 2.057 to 3.363, did not contain the null hypothesis, 4, suggests that

the milestones were helpful.

 41

Team Project Contribution

1 2 3 4 5 6 7
Response

Figure 4.11 Team Project Contribution Chart

Table 4.11 Team Project Contribution Data Part 1

Statistic Min Value Max Value Mean Variance
Value 1 7 2.5 2.27
Table 4.12 Team Project Contribution Data Part 2
Statistic Standard Total t-value Confidence
Deviation Responses Interval
Value 1.51 14 -3.717 1.785, 3.215

The data for team project contribution has a right skew. The maximum value, 7,

can also be considered an outlier due to its distance from the main portion of the data.

This will not be taken out though as it describes the issues one group faced while trying

to complete the project. With a confidence interval of 1.785 to 3.215, the data suggests

that the team members had an equal contribution to the team projects.
 42

Team Project Issues

15

12

0
Technical Team-Related

Figure 4.12 Team Project Issues Chart

All participants reported having technical issues with their team projects.

Participants reported having a hard time getting used to the engine and figuring out how

to implement their game ideas. Once again, the lab problems with the Unreal Engine

were brought up as issues.

Team Project Preference

1 2 3 4 5 6 7
Response

Figure 4.13 Team Project Preference Chart

 43

Table 4.13 Team Project Preference Data Part 1

Statistic Min Value Max Value Mean Variance
Value 2 7 4.64 2.71
Table 4.14 Team Project Preference Data Part 2
Statistic Standard Total t-value Confidence
Deviation Responses Interval
Value 1.65 14 1.451 3.859, 5.421

Participants were asked if they would prefer a large individual project over the

current team project. The data showed a slight left skew and no one strongly agreed with

the idea of having large individual projects. The confidence interval, 3.859 to 5.421,

contains the null hypothesis of 4. This suggests that the participants had no preference for

the type of project given to them.

Exercises and Team Projects

1 2 3 4 5 6 7
Response

Figure 4.14 Exercise and Team Project Chart

Table 4.15 Exercise and Team Project Data Part 1

Statistic Min Value Max Value Mean Variance
Value 1 7 4.07 4.38
 44

Table 4.16 Exercise and Team Project Data Part 2

Statistic Standard Total t-value Confidence
Deviation Responses Interval
Value 2.09 14 .125 3.081, 5.059

While the largest portion of participants somewhat agreed that the exercises

helped the project, participants also had a large number that chose “disagree” and

“strongly disagree”. Some students stated that the exercises helped them to understand

the engine while others said that the exercises did not help because their game covered a

different genre. The confidence interval, 3.081 to 5.059, contained the null hypothesis,

which suggests that participants thought that the exercises did not help to complete the

team projects.

Participants wanted to form teams at an earlier time. This would allow them more

time to complete the project and understand their teammate’s skills. They would also like

the students to split by their skills. By splitting them, the teams could have an even

distribution of artists, programmers, and designers.

 45

4.2.4 Course Format

Engine Preference
12

0
Unreal Unity

Figure 4.15 Engine Preference Chart

A majority of participants preferred the Unreal Engine over the Unity 3D engine.

They reported that the Unreal Engine was capable of doing some amazing things and that

it would look good on a resume. Participants that preferred Unity liked it for its simple

interface and familiarity.

 46

Class Format

1 2 3 4 5 6 7
Response

Figure 4.16 Class Format Chart

Table 4.17 Class Format Data Part 1

Statistic Min Value Max Value Mean Variance
Value 1 5 2.71 2.07
Table 4.18 Class Format Data Part 2
Statistic Standard Total t-value Confidence
Deviation Responses Interval
Value 1.44 14 -3.352 2.028, 3.392

When asked if the participants preferred the lab-oriented class, the data had a right

skew. The minimum value was 5 for somewhat disagree. Along with the confidence

interval, 2.028 to 3.392, not containing the null hypothesis, the data suggests that

participants preferred a lab-oriented class over a traditional lecture course.

 47

Course Distribution
45
42
39
36
33
Average Percentage 30
27
24
21
18
15
12
9
6
3
0
Lecture Lab

Figure 4.17 Course Distribution Chart

Participants were asked what should be the ideal course format. On average

students wanted lecture to take up 19.79% of the course while the lab format on average

would take up 40.71%. Along with the results above, the data suggests that participants

would like the course to have a larger lab orientation than lecture. If a lecture were to be

added to the course, participants wanted it to focus on game development concepts such

as coding examples, game design discussions, and discussing the current state of the

video game industry.

 48

4.2.5 Course Performance

Game Development Confidence

1 2 3 4 5 6 7
Response

Figure 4.18 Game Development Confidence Chart

Table 4.19 Game Development Confidence Data Part 1

Statistic Min Value Max Value Mean Variance
Value 2 7 3.57 2.42
Table 4.20 Game Development Confidence Data Part 2
Statistic Standard Total t-value Confidence
Deviation Responses Interval
Value 1.55 14 -1.038 2.836, 4.304

When asked about their confidence in game development, the data has a right

skew with possible outliers in the maximum value, 7. A majority of students chose

“somewhat agree” while 2 students strongly disagreed with the statement. These two

answers widened the confidence interval to 2.836 to 4.304. While the confidence contains

the null hypothesis, there seemed to be a trend to agree that participants were confident in
 49

their game development skills. However, the data suggests that the students did not agree

or disagree regarding how confident they are in game development.

Unreal Engine Confidence

1 2 3 4 5 6 7
Response

Figure 4.19 Unreal Engine Confidence Chart

Table 4.21 Unreal Engine Confidence Data Part 1

Statistic Min Value Max Value Mean Variance
Value 3 7 4.29 2.22
Table 4.22 Unreal Engine Confidence Data Part 2
Statistic Standard Total t-value Confidence
Deviation Responses Interval
Value 1.49 14 .728 3.585, 4.995

While the data for the participants confidence with the Unreal Engine has a right

skew, the minimum value is 3 for “somewhat agree”. This leads to a confidence interval

of 3.585 to 4.995 that contains the null hypothesis. This suggests that participants were

neither confident nor unconfident with their emerging Unreal Engine skills.
 50

Game Development Aspiration

1 2 3 4 5 6 7
Response

Figure 4.20 Game Development Aspiration Chart

Table 4.23 Game Development Aspiration Data Part 1

Statistic Min Value Max Value Mean Variance
Value 1 6 3 2.92
Table 4.24 Game Development Aspiration Data Part 2
Statistic Standard Total t-value Confidence
Deviation Responses Interval
Value 1.71 14 -2.188 2.191, 3.809

The data has a slight right skew for their aspirations to continue in game

development. The maximum value was 6 for disagree. With a confidence interval of

2.191 to 3.809, the data suggests the participants were motivated to pursue game

development.
 51

Interest in Advance Course

12

0
Yes No

Figure 4.21 Interest in Advance Course Chart

9 of the 14 participants want to continue to the advance game development course.

5 participants do not want to continue in to the next game development course.

Overall Experience

1 2 3 4 5 6 7
Response

Figure 4.22 Overall Experience Chart

 52

Table 4.25 Overall Experience Data Part 1

Statistic Min Value Max Value Mean Variance
Value 2 7 3.07 2.99
Table 4.26 Overall Experience Data Part 2
Statistic Standard Total t-value Confidence
Deviation Responses Interval
Value 1.73 14 -2.011 2.251, 3.889

The data is skewed to the right with a majority of responses ranging in 2 and 3,

“agree” and “somewhat agree”. Participants enjoyed the course as they were able to learn

how to create games for future career prospects. While some participants reported the

engine problems being too much of an issue, most students did not report it as an issue.

The confidence interval, 2.251 to 3.889, does not contain the null hypothesis. This

suggests that the overall experience of the course was good.

Final Grades
15

12

0
A B C D F

Figure 4.23 Student Grades Chart

Student grades had a right skew with a majority of students receiving an A in the

course. These students completed most of the exercises and created a satisfactory team
 53

project. Students that received a B or C did not complete all of the exercises. The 2 F

students did not complete the exercises or participate in the team projects.

Instructor Performance

1 2 3 4 5
Response

Figure 4.24 Instructor Performance Chart

Table 4.27 Instructor Performance Data Part 1

Statistic Min Value Max Value Mean Variance
Value 1 5 2.5 1.04
Table 4.28 Instructor Performance Data Part 2
Statistic Standard Total t-value Confidence
Deviation Responses Interval
Value 1.02 14 -1.834 2.017, 2.983

Participants’ report of how well the course was taught showed a right skew along

with a confidence interval of 2.017 to 2.983. For this question alone, the null hypothesis

was 3 and the Likert scale was set to 5. This difference from the other questions was an

unintentional error. Even with this change, the null hypothesis was not within the

confidence interval, which suggests that the instructor performance was adequate.
 54

In future iterations of the course, participants would like the technical issues to be

fixed along with a greater emphasis on demoing the exercises. Two students reported in

the free response that they were disappointed in the course and how it was run. Some

students were also disappointed that the course used Unreal instead of Unity. Other than

these two instances, the overall results for the course were positive.

4.3 Discussion

The students were responsive with the survey. One of the initial worries for the

thesis was that the students would ignore the survey due to it being optional. It is

alarming that a large portion of the sample consisted of males but the course only had a

few female students. Students were most likely upper classman because the prerequisites

for the course tend to be taken during the sophomore year. This course is currently

marketed mostly for CGT students. While the course can benefit by introducing it to a

wider audience, this audience would need to have the foundation provided by the

prerequisite courses.

The problems with CGT 241 seem to have been addressed. Students had minor

issues with modeling or creating art assets. There were a few students that needed helped

but they were either taking the course at the same time or they had gotten permission to

take the course instead of completing the prerequisites. On the other hand, the course

revealed a gap with the students’ programming knowledge. Students did not understand

how CGT 215 helped them to understand programming in the Unreal Engine. This is a

gap that will need to be addressed in future work.

 55

While the data in results shows a neutral view on exercise difficulty, there was a

trend of students having a hard time completing exercises. Whenever students had an

issue with the engine while completing exercises, they generally stopped working to ask

for help rather than finding the solution on their own. This is an introductory course but

students will need to take some initiative with solving issues when they work in the video

game industry. However, the issues in the lab were at the time unexplainable and

hindered some of their progress. Another issue some students faced was being unable to

understand some of the instructions for the exercises. Students were using different

versions of Unreal and things often change between versions. This along with being new

to game development made it difficult for some students to complete exercises. Adding

additional images to the instructions of the exercises and further exploring their goals

should help to improve the students understanding of basic game development skills.

Team projects generally went well. While students had trouble creating content

that they were designing, they were able to work together to create some interesting

projects. One team experienced some issues when a member stopped showing up for

class. This team was then at a disadvantage with one less person working on the project.

Thankfully there were still able to work through the problems and to turn in their team

project. This group most likely contributed to some of the negative team project results.

Team projects could be started at an early time before the mid semester. This would give

students more time to complete their projects and to address the technical issues that all

of the participants in the study faced. Some students would have liked the team projects

to be more structured. This structure would include factors such as dividing skills, setting

an exact game project, and choosing a specific engine. While these factors could benefit
 56

the higher course, they go against the exploration mindset we have for these projects. The

goal was for students to learn and explore on their own how games are created. The

course allows for the student to make mistakes as long as they grow outside of the

foundation that is provided. Future course focus on creating a good game but the goal of

this course is to learn how to create a game. Participants also reported a neutral stance on

the exercises helping the team projects. This could be explained by students choosing

projects of a different genre than the exercises and from others that chose to use a

different engine than Unreal. The goal of the exercises is to give them the basic idea of

how the engine works. They are not there to complete the team project for them. Students

need to be able to freely explore in order to understand the difficulties of game

development. If restrictions were to be placed, it would be at a lower level course.

A majority of students preferred Unreal over Unity. They understood that it was a

powerful engine that could help them find a job. Even if we switched to Unity, students

need to be prepared to learn new software when working in the industry. Companies do

not always use the same engine, so they will need to be able to adapt and transfer their

skills to the new tool. Students also seemed to enjoy the lab format. As an instructor, it

was easy to talk to students and help them with their work during class time. However, I

was not able to provide more demonstrations or an explanation. The changes to the

exercises took a large portion of my preparation time that would have otherwise been

spent creating demonstrations. Now that the engine works in lab, it is possible for future

iterations to have more demonstrations. Students also reported wanting a larger portion of

the course devoted to lecture. While it is good that they want to learn more about game

development, this takes time away from teaching them how to make good games.
 57

Discussions on good design are handled at the advance level where students are tasked

with creating a fun game.

Students generally did not report positive results for confidence in game

development. The question was most likely worded incorrectly as it should have asked if

they had learned something instead of an increase in confidence. Students might have

actually learned that they do not know enough about game development. This can cause a

decrease in confidence even if they receive more knowledge from the course. Also, it was

nice to see that a majority of students wanted to continue in game development. This

shows that the course is successful in gaining student interest. There were some negative

results with students no longer interested in game development. It seems these students

were expecting a different course that taught different skills. Overall, students did well in

the course if they completed the exercises and did well on the team project. There were

some students that did not turn all of their exercises or they showed a bad team project.

Either way, students generally passed the course. Even with the issues, students generally

enjoyed the course and learned some of the basics of game development.

4.4 Recommendations

In order to prepare a course, there needs to be an understanding of what is taught

within and outside of the course. To fix the introductory course, there needs to be some

changes made to the overall curriculum.

 58

Figure 4.25 Recommended Curriculum

Figure 4.25 depicts a recommendation for the core curriculum for undergraduate

game development at Purdue University. It divides the different areas of game

development into tracks that expand on certain topics in order to prepare students for a

career in game development.

At the beginner level, students need to understand the basics of art, programming,

and design. While they may not be going into the se specific fields, they need to have a

basic understanding of what is happening in those other fields and how they can work

together to create a product. Overall, the goal of the beginner level is to give a basic

foundation to students with little to no knowledge in game development and to also draw

people into the curriculum. The introductory art course would be CGT 241. According to
 59

the survey and the student’s performance, the course is preparing them for game

development. The course itself is also going through some changes. At the time that this

thesis was written, CGT 241 has just opened up to the entire university in order to draw

in more animation students to the department. The introductory game course would be

new to Purdue University. Students seem eager to discuss the game industry even before

understanding how to create games. This course would be used to give students a basic

understanding of the design of games while also getting students interested in game

development. Whitehead’s course at the University of Santa Cruz is a good example of

what this design course would accomplish. Students would play games and discuss why a

game is fun or good while also coming up with their own ideas. Introductory

programming would be CGT 215. While the course has been suggested to be inadequate

in preparing students for game programming, it does teach students the basics of general

programming. Game programming needs another course in order to prepare students for

the introductory game development course.

At the novice level, students can decide to specialize in either art or programming.

This specialization can help them learn about their topic of interest before working on a

team. The video game art course would expand on the basic concepts taught in CGT 241

by applying them to a game. The course would be similar to Wynters (2007) in that

students would be interacting with an engine but only changing it by applying different

models, textures, and terrains. This will decrease the modeling load in the introductory

course in order to explore other subjects. The video game programming course was

suggested by the data in this thesis. Students are not learning enough about programming

within a game development environment. This course would take students through
 60

programming exercises within a game development engine. They would learn how to

manipulate objects and to change, store, or access data. This would be similar to DePaul

Universities game development course where they use XNA to teach basic coding

principles (Linhoff & Settle, 2008). By adding this course, the introductory game

development course can continue using its current programming methods.

The intermediate level would be CGT 345, Introduction to Game Development.

The focus of this course would be to bring the art and programming students together to

create a game. The goal would be the same in that it teaches students how to create a

functional game. Due to this focus, students are able to experiment instead of striving to

create a “fun” experience. They can try different methods of creating their game idea

without worrying if the idea is necessarily fun. Instead, they are learning about the time

and effort it takes to create a game.

The advance level would take place over a year, two semesters. Students would

pair off into groups to work on a game concept for the entirety of the course. This would

take a studio approach and emulate the video game industry. The goal is to create a fun

experience that is capable of being published in the market. Students would not only

receive experience working in an industry environment but also get a portfolio piece that

can help them get a job out of college.

Together, these courses form a curriculum to teach students about game

development. It can be expanded as well by adding other options. Electives could be

added to expand a student’s knowledge. For example, a student can add the video game

narrative course as an elective to better understand how stories are written in games. This
 61

recommendation is just for the core curriculum in order to refine the introductory game

development course.

4.5 Future Work

While this recommendation is based on data from this thesis and other game

development courses, it is still a theoretical curriculum. Further testing needs to be done

in order to see if there are any issues and if it is a practical application. Each course has to

provide a step into a game development career. This curriculum may not also work for

every institution. Purdue University teaches using a general approach that may not work

for an art or programming specific background. Either way, those programs need to

emulate an industry setting in some form. By testing and reforming the game

development program, universities can be closer to having an impact on the video game

industry.

4.6 Conclusion

The course had an overall good performance in that it provided students with the

basic knowledge to create games. While students wanted to explore areas such as design,

it was not the primary focus of the course. A gap was shown in students’ knowledge of

programming. They felt that the course was too big of a jump from the prerequisite

course. This could be solved by expanding the game curriculum at Purdue University to

specialize in certain areas. Now that the Unreal Engine is also fixed, it will be easier for

students to have access to all of the Unreal Engine’s features. A future analysis needs to
 62

be done to see if any other factors influenced the course and to see if the

recommendations for the course are correct for the university.

 63

LIST OF REFERENCES
 63

LIST OF REFERENCES

Anderson, E., & McLoughlin, L. (2007). Critters in the classroom: a 3D computer-game-

like tool for teaching programming to computer animation students. ACM
SIGGRAPH 2007 Educators Program. Retrieved from
http://dl.acm.org/citation.cfm?id=1282048

Bayliss, J. (2009). Using games in introductory courses: tips from the trenches. ACM
SIGCSE Bulletin, 337–341. Retrieved from
http://dl.acm.org/citation.cfm?id=1508989

Dondlinger, M. J., & Wilson, D. a. (2012). Creating an alternate reality: Critical, creative,
and empathic thinking generated in the Global Village Playground capstone
experience. Thinking Skills and Creativity, 7(3), 153–164.
doi:10.1016/j.tsc.2012.02.001

El-Nasr, M. S., & Smith, B. K. (2006). Learning through game modding. Computers in
Entertainment, 4(1), 7. doi:10.1145/1111293.1111301

Gestwicki, P., Sun, F., & Dean, B. (2008). Teaching game design and game programming
through interdisciplinary courses. Journal of Computing Sciences in …, 8668, 110–
115. Retrieved from http://dl.acm.org/citation.cfm?id=1409791

Graff, E. De, & Kolmos, A. (2007). Management of change: implementation of problem-

based and project-based learning in engineering (pp. 1–43). Retrieved from
http://forskningsbasen.deff.dk/Share.external?sp=S251862f0-a619-11db-b8eb-
000ea68e967b&sp=Saau

Graft, K. (2014, July 22). Game Developer Salary Survey 2014: The results are in!
Retrieved February 10, 2015, from
http://gamasutra.com/view/news/221533/Game_Developer_Salary_Survey_2014_T
he_results_are_in.php

Hwang, G.-J., Hung, C.-M., & Chen, N.-S. (2013). Improving learning achievements,
motivations and problem-solving skills through a peer assessment-based game
development approach. Educational Technology Research and Development, 62(2),
129–145. doi:10.1007/s11423-013-9320-7
 64

Linhoff, J., & Settle, A. (2008). Teaching game programming using XNA. ACM SIGCSE
Bulletin, 40(3), 250. doi:10.1145/1597849.1384338

McGill, M. (2008). Critical skills for game developers: an analysis of skills sought by
industry. In Proceedings of the 2008 Conference on Future Play: … (pp. 89–96).
Retrieved from http://dl.acm.org/citation.cfm?id=1497000

Owen, D. (2013, April 3). Is it Worth Doing a Degree in Video Games? Retrieved March
15, 2015, from http://www.ign.com/articles/2013/04/02/is-it-worth-doing-a-degree-
in-video-games

Pease, M. a., & Kuhn, D. (2011). Experimental analysis of the effective components of
problem-based learning. Science Education, 95(1), 57–86. doi:10.1002/sce.20412

Schultz, W. (n.d.). AAA Game. Retrieved April 3, 2015, from

http://gameindustry.about.com/od/glossary/g/Aaa-Game.htm

Sung, K., Rosenberg, R., Panitz, M., & Anderson, R. (2008). Assessing game-themed
programming assignments for CS1/2 courses. Proceedings of the 3rd International
Conference on Game Development in Computer Science Education - GDCSE ’08,
51–55. doi:10.1145/1463673.1463684

Slick, J. (n.d.). Creating a UV Layout. Retrieved April 3, 2015, from

http://3d.about.com/od/3d-101-The-Basics/a/Surfacing-101-Creating-A-UV-
Layout.htm

Slick, J. (n.d.). Preparing a Model for 3D Printing. Retrieved April 3, 2015, from
http://3d.about.com/od/Creating-3D-The-CG-Pipeline/ss/Preparing-A-Model-For-
3d-Printing-Model-To-3d-Print-In-5-Steps_5.htm

Timcenko, O., & Stojic, R. (2012). On Problem Based Learning and Application to
Computer Games Design Teaching. International Journal of Emerging
Technologies in …, 7(1). Retrieved from http://www.editlib.org/p/44963/

Unreal Engine 3. (n.d.). Retrieved March 16, 2015, from

http://www.giantbomb.com/unreal-engine-3/3015-86/games/

Ward, J. (2008, April 29). What is a Game Engine? - GameCareerGuide.com. Retrieved

February 17, 2015, from
http://www.gamecareerguide.com/features/529/what_is_a_game_.php

Whitehead, J. (2008). Introduction to game design in the large classroom. Proceedings of

the 3rd International Conference on Game Development in Computer Science
Education - GDCSE ’08, 61–65. doi:10.1145/1463673.1463686
 65

Wichrowski, M. (2013). Teaching augmented reality in practice: tools, workshops and

students’ projects. Proceedings of the International Conference on …. Retrieved
from http://dl.acm.org/citation.cfm?id=2500362

Wood, D. F. (2008). Problem based learning. BMJ (Clinical Research Ed.), 336(7651),
971. doi:10.1136/bmj.39546.716053.80

Wynters, E. (2007). 3D video games: no programming required. Journal of Computing

Sciences in Colleges, 105–111. Retrieved from
http://dl.acm.org/citation.cfm?id=1181875
APPENDICES
 66

Appendix A IRB Approval Letter

 67

Appendix B Survey

1. What is your gender?

# Answer Response %
1 Male 15 88%
2 Female 2 12%
Total 17 100%

Statistic Value
Min Value 1
Max Value 2
Mean 1.12
Variance 0.11
Standard Deviation 0.33
Total Responses 17

2. What year are you in?

# Answer Response %
1 Freshman 0 0%
2 Sophomore 0 0%
3 Junior 10 59%
4 Senior 7 41%
5 Graduate 0 0%
Total 17 100%

Statistic Value
Min Value 3
Max Value 4
Mean 3.41
Variance 0.26
Standard Deviation 0.51
Total Responses 17
 68

3. What is your major?

Text Response
Computer Graphics Technolgy
CGT
CGT
Computer Graphics Technology
CGT
Computer Graphics Technology
CGT
Computer Graphics Technology
Computer Graphics Technology
CGT
CGT
CGT
Computer Graphics Technology
CGT
cit
CGT
computer graphics technology

Statistic Value
Total Responses 17

4. CGT 241, or its modeling equivalent, was useful in completing

this course:
# Answer Response %
Strongly
1 6 35%
Agree
2 Agree 4 24%
Somewhat
3 3 18%
Agree
Neither
4 Agree nor 3 18%
Disagree
Somewhat
5 0 0%
Disagree
6 Disagree 0 0%
Strongly
7 1 6%
Disagree
Total 17 100%
 69

Statistic Value
Min Value 1
Max Value 7
Mean 2.47
Variance 2.64
Standard Deviation 1.62
Total Responses 17

5. CGT 215, or its programming equivalent, eas useful in

completing this course:
# Answer Response %
Strongly
1 2 12%
Agree
2 Agree 5 29%
Somewhat
3 1 6%
Agree
Neither
4 Agree nor 6 35%
Disagree
Somewhat
5 1 6%
Disagree
6 Disagree 1 6%
Strongly
7 1 6%
Disagree
Total 17 100%

Statistic Value
Min Value 1
Max Value 7
Mean 3.35
Variance 2.87
Standard Deviation 1.69
Total Responses 17
 70

6. What types of modeling, coding, or game software were you

familiar with before this course?
Text Response
Modeling - Maya Coding - C and Java
Maya 2013, java programming language
I had not taken a 3D modeling class, however was taking CGT 241 alongside this class. I
have had experience with C#, Java, Lua and minimal Unity.
I had a fair amount of modeling experience in Maya and I knew some coding in C++. I
had also some online tutorial experience in Unity.
Maya, Visual Studio, Unity
Autodesk Maya (2013 & 2014) and Microsoft Visual Studio (C++)
maya
Maya
I took CGT241 in tandem, which made things difficult early on. I'm somewhat familiar
with code, as I used to be a CS major before CODOing. I've messed around with various
level editors for games before, creating things but nothing huge or commercial.
Standard modeling
Maya, Catia
Maya, Unreal, programming in Java.
Maya modeling, some Python, Jython, and C+.
Modeling in maya and 3ds max
none
CNIT 105, C programming
blender,maya,skecthup,unity,3ds max,visual studio

Statistic Value
Total Responses 17

7. How difficult, on average, would you rate the exercises?

# Answer Response %
1 Very Easy 0 0%
2 Easy 1 7%
Somewhat
3 4 29%
Easy
4 Neutral 2 14%
Somewhat
5 3 21%
Difficult
6 Difficult 2 14%
Very
7 2 14%
Difficult
Total 14 100%
 71

Statistic Value
Min Value 2
Max Value 7
Mean 4.50
Variance 2.58
Standard Deviation 1.61
Total Responses 14

8. What was the easiest exercise?

# Answer Response %
Art (modeling,
1 10 71%
texture, etc.)
2 Programming 2 14%
3 Design 2 14%
Total 14 100%

Statistic Value
Min Value 1
Max Value 3
Mean 1.43
Variance 0.57
Standard Deviation 0.76
Total Responses 14
 72

9. Why?
Text Response
Know how to model better than programming and the design process was already laid out
for us in exercises
Most familiar with how to do it.
Art styles can vary damatically and there's always a wide range of acceptable results.
It was the easiest for me because I already had a decent amount of modeling and
texturing experience.
You can style it the way you want
I am familiar with Autodesk Maya, so I can model (inorganic) models pretty quickly as
well as texture them . I am also slightly more on the artistic side versus programming.
However, I am also fairly new to programming, so I have not been able to code very
much (outside of the courses).
I learned it before
I like to design
Art requires skills such as modeling that I was not developed with. Programming portions
were step-by-step, so they were easy if time consuming when you did things right. But if
you did things wrong, due to the fact that you didn't understand the underlying logic
behind quite everything you were doing and the big codebases you were building on, it
could be hard to find a solution. Blueprints helped, but Unreal 4's newness hurt, so it
balanced out.
Unreal didn't work for me
Because it was pretty much step by step on this, the only time it was an issue was when
something was mistyped in the instructions and I had to determine what it was supposed
to be.
Because Maya actually works on the lab computers.
major related
Both the in-engine tools and external programs made art fairly easy. Design wasn't bad
either.

Statistic Value
Total Responses 14

10. What was the hardest exercise?

# Answer Response %
Art (modeling,
1 1 7%
texture, etc.)
2 Programming 12 86%
3 Design 1 7%
Total 14 100%
 73

Statistic Value
Min Value 1
Max Value 3
Mean 2.00
Variance 0.15
Standard Deviation 0.39
Total Responses 14

11. Why?
Text Response
What programming skills I have are too simple to comprehend gaming programming
Unaware of the language used.
I didn't much care for Unreal's blueprint system and I've yet to delve into C++. Compared
to other programming paradigms it seemed odd.
I didn't have much in the way of programming knowledge.
I was starting from scratch, I didn't know anything beforehand
As previously mentioned, I am pretty new to programming, so I do not have much
experience in coding prior to CGT 215. Additionally, some of the coding for Unreal is
complicated and/or difficult to find.
I do not have much knowleage about it
I'm really bad at programming
See above.
Unreal didn't work for me
I wouldn't really call it that hard, it was just overall the hardest I suppose by just a little
bit.
Because Unreal doesn't work on the lab computers.
never touched before
For me, there was a considerable jump in having taken CNIT 105 and CGT 215 for
programming classes, then trying to apply that head-on in a real game engine making a
project for CGT 345. There was a real disconnect between the first two classes, and this
one. There does need to be a programming class in-between that helps enable code
experience to be applied to a professional game engine.

Statistic Value
Total Responses 14
 74

12. Which exercises were the most useful?

Text Response
The exercises meant to be done in lab, because visual studio never worked in lab or at
home
All were equally useful.
Being introduced to the different features in Unreal were helpful.
I really thought the exercises which taught us how to bring in 3D models with their
textures and place them inside of the Unreal world were the most useful for me.
Exercise 2
The introduction to Unreal (first couple of exercises) as well as any of the modeling
exercises were the most useful.
Programming
Modeling ones and implementing
The most useful exercises were the ones that dealt with functions of Unreal (or Unity)
rather than creating assets for them. This is because the exercises that were just modeling,
texturing or so on didn't actually teach anything new beyond how to import things into
Unreal, which is mostly self-explanatory.
Unity ones
I'd like to think all of them were.
The terrain modeling ones
whole set
The big project itself was by far the most useful, with the exercises often pointing to a
way to do something, sometimes better than what you had tried before. Exercises should
be about exploring what's possible, a bit more than how to do it.

Statistic Value
Total Responses 14
 75

13. What steps, if any, would you recommend to improve the

course exercises?
Text Response
More images of the blueprints
Make sure the steps are complete and there's no missing or incomplete steps.
I would suggest proving more explanation of each step in the labs (eg, why we are doing
what we're doing, how we will use it, where this step is common in games, etc). I would
much rather have made less progress with a game and spent more time developing a
sturdy foundation to begin learning from. I feel one can't really teach a game design
engine as much as they can provide a solid base for students to build off of and learn how
to teach themselves.
A bit more of explanation for why and how the programming and the node placement and
connections are working would be nice. It felt like we were really just following step by
step and hoping that things were going to work and if things went wrong we really didn't
know how to fix it.
Stick with one program that both Prof and TA know well, and get more Unity licenses for
the lab
Be sure to include more screenshots of the coding portions; I had trouble with some of
the more difficult coding parts, especially when there was not a screenshot on what our
code should look like. Also, some more exercise demos would be helpful, especially for
some of the later exercises in addition to the first couple exercises.
Tell students how each steps work
None
Explain in more detail why certain things are being done in the instructions, so it's not
just a bullet point list. Not much explanation is needed, but some context particularly in
complicated code sections or similar would help students to fix problems if they did
something wrong. I was also disappointed that there wasn't more (any, really) on the
principles of game design, level design or such. Perhaps that is intended for the follow-up
course, and/or perhaps this course is merely meant to address the technical knowledge of
how to do things in Unreal. I would've liked some, for what it's worth.
Actually teach course lessons, don't use an engine that doesn't compile.
Proofread things so that the person doing the exercises doesn't have to fumble around
confused because something they were told to do doesn't exist or is the wrong thing.
Choose a game engine that actually works
it's good overall
Sometimes, trying to follow instruction was difficult. There were also times when if
something was done incorrectly in a previous exercise, or at least done differently, later
exercises became far more difficult. Exercise 9 was especially long and tough if not all of
the previous exercises were done right. A bit of smoothing of each week's exercise
load, and a broad-view plan that shows each week in context may be useful. Also:
alternative approaces, or at least methods to make an alternative method work with a
following week's plan work may help. Lots of work in that, though.
 76

Statistic Value
Total Responses 14

14. The team projects went well this semester:

# Answer Response %
Strongly
1 1 7%
Agree
2 Agree 6 43%
Somewhat
3 2 14%
Agree
Neither
4 Agree nor 3 21%
Disagree
Somewhat
5 2 14%
Disagree
6 Disagree 0 0%
Strongly
7 0 0%
Disagree
Total 14 100%

Statistic Value
Min Value 1
Max Value 5
Mean 2.93
Variance 1.61
Standard Deviation 1.27
Total Responses 14
 77

15. Why?
Text Response
Not very structured but still managable
We all worked well together.
I for one had quite a solid group. We had a good distribution of talent and we worked
very well together.
My groups project turned out really well, I felt but there were a few groups which didn't
manage to get a whole lot done. But all in all, I did feel like the group projects were a
success.
Some groups weren't completely prepared or finished because of lack of knowledge of
availability of help
Overall, my group went pretty smoothly on our project with the exception of one of the
group members. Because he pretty much never showed up to class after the first couple
of weeks, we did not expect him to contribute much to the project, and by the time he did,
it was already too late. With him as an exception, we managed to get our game mostly
operating.
All groups did good project
Team mates did a lot
I wish we had more time to polish our product, but it all went pretty well apart from the
fact that one team member stopped coming to class.
Not enough time
It was kind of disorganized from the beginning it felt like. We started off being told that
we should just have ideas and then we'd decide on whether we liked the idea or not, but
then it seemed like we completely skipped that and were expected to just have our ideas
ready by the next meeting.
We weren't taught how to use unity.
lacking guidance
TIME. Always need more time. Until it's done. Then more time to fix the bugs.

Statistic Value
Total Responses 14
 78

16. The weekly milestones were helpful:

# Answer Response %
Strongly
1 3 21%
Agree
2 Agree 3 21%
Somewhat
3 5 36%
Agree
Neither
4 Agree nor 2 14%
Disagree
Somewhat
5 0 0%
Disagree
6 Disagree 1 7%
Strongly
7 0 0%
Disagree
Total 14 100%

Statistic Value
Min Value 1
Max Value 6
Mean 2.71
Variance 1.91
Standard Deviation 1.38
Total Responses 14

17. All team members contributed meaningfully to the project:

# Answer Response %
Strongly
1 3 21%
Agree
2 Agree 5 36%
Somewhat
3 5 36%
Agree
Neither
4 Agree nor 0 0%
Disagree
Somewhat
5 0 0%
Disagree
6 Disagree 0 0%
Strongly
7 1 7%
Disagree
Total 14 100%
 79

Statistic Value
Min Value 1
Max Value 7
Mean 2.50
Variance 2.27
Standard Deviation 1.51
Total Responses 14

18. The challenges we faced were primarily technical or team-

related
# Answer Response %
1 Technical 14 100%
Team-
2 0 0%
Related
Total 14 100%

Statistic Value
Min Value 1
Max Value 1
Mean 1.00
Variance 0.00
Standard Deviation 0.00
Total Responses 14
 80

19. Why?
Text Response
Each team member focused on specific things, so it was difficult to learn all aspects of
creating games
We didn't have any problems with our group
In my case I had a mix of both technical and team-related. I certainly had to pull a lot
more weight, but at the same time I can't expect every member to be a leader of every
group they're in.
Our team worked together really well but we did come across a few issues with the
models as well as some code issues we had to troubleshoot.
The program was integrated in the course at the last minute, so we lost days of learning
and we didn't know much of anything about the complicated engine
Unreal Engine 4 is pretty new, so there was not a lot of help/references out their for some
of the features we wanted in our game (at least for me and one other group member of
mine ran into this issue). However, we also had some team-related issues too, such as a
consistently absent group member and a little bit lacking on the artistic side of the game
development.
s
Time windows
Besides simple lack of time, most of the issues we had centered around using and being
comfortable with the engine. Ignoring the one team member who left our group, we
worked together fine.
Time constraints
Just getting things done and organized.
We weren't taught unity
unreal 4.3 doesn't support video assets
If a team member is not contributing meaningfully, the team's project may have to make
adjustments that take the planned project's end beyond the end of the semester. This
affects the overall team's grade. Then again, being able to explain what went wrong, and
the steps taken to address the issue seemed to work well to keep problems such as this
from becoming a real issue.

Statistic Value
Total Responses 14

20. I would prefer the class be taught using:

# Answer Response %
1 Unreal 9 64%
2 Unity 5 36%
Total 14 100%
 81

Statistic Value
Min Value 1
Max Value 2
Mean 1.36
Variance 0.25
Standard Deviation 0.50
Total Responses 14

21. Why was this engine preferred?

Text Response
Unreal is obviously a powerful engine, but it is not beginner friendly, where Unity
It is apparently a desired skill by employers
I feel like most of the students in the class are going to be beginners to game
development and Unity has always been said to be a good starting place. If there were to
be a higher up level of the class, I would then suggest Unreal. Unity is certainly better
for beginners, but Unreal is better for making a profession.
It is very unique and powerful. My group made our game using Unity because our coder
knew C# but I would have much rather used Unreal for the power it has behind it.
Because the Prof knows a lot more about it, thus he can actually help out in class instead
of just directing us.
For me, Unreal has much more recognition (and most likely potential) than Unity does
(even if the fourth version is somewhat new), and it looks better on one's application/skill
or program set. After all, this is a game engine that most of the big name game
companies use.
new engine, amazing effect
Interesting
I can't say as much about Unity, but Unreal seems reasonable enough and it seems to be
more the industry-standard. It just may take some time to know the engine and therefore
teach the course better.
It worked
Unity was easier but I didn't get to spend too much time with it so I don't really have
enough experience to say whether it would actually be easier or not.
Because unreal doesn't work on the lab computers.
new, popular, and more fun.
Price, plans of use, blueprint system vs C# only, industry recognition, preferred company.
Others may apply.

Statistic Value
Total Responses 14
 82

22. I would have preferred a large individual semester project

instead of a team project:
# Answer Response %
Strongly
1 0 0%
Agree
2 Agree 2 14%
Somewhat
3 1 7%
Agree
Neither
4 Agree nor 4 29%
Disagree
Somewhat
5 2 14%
Disagree
6 Disagree 3 21%
Strongly
7 2 14%
Disagree
Total 14 100%

Statistic Value
Min Value 2
Max Value 7
Mean 4.64
Variance 2.71
Standard Deviation 1.65
Total Responses 14

23. The exercises helped to complete the team projects:

# Answer Response %
Strongly
1 2 14%
Agree
2 Agree 1 7%
Somewhat
3 4 29%
Agree
Neither
4 Agree nor 1 7%
Disagree
Somewhat
5 1 7%
Disagree
6 Disagree 3 21%
Strongly
7 2 14%
Disagree
Total 14 100%
 83

Statistic Value
Min Value 1
Max Value 7
Mean 4.07
Variance 4.38
Standard Deviation 2.09
Total Responses 14

24. How did it help or hinder?

Text Response
If the team project was a first person game, it would help. But my project was a 2D
platformer, so the exercises did not help the team project.
The exercises took time away from the project.
The exercises did not apply to my team project because we used Unity. I would have
liked, however, to have had the option to complete Unity exercises instead of Unreal.
The exercises dealt with many things that my group ended up using in our group project.
It helped us learn how to use the program along the way, although some of us needed to
know more complicated programming earlier on.
The exercises helped me on navigating through Unreal's various featuresnmainly, but it
also help me with setting up a (simple) game and coding within it as well as how to use
import various items within it and adjusting them as necessary.
each exercise is very important part of making game
Help to know unreal better
I wasn't our groups resident programmer, who the exercises may have helped somewhat.
That being the case, the exercises had almost no bearing on my group work at all.
Instead, they were just separate work I fell behind on while doing group work.
It was in unreal, which didn't work on the lab computers.
It really did neither, since I was mainly doing the artwork portion of things and therefore
I ended up only needing a bit of the knowledge in order to place things in the game.
They wasted my time and frustrated me
somewhat
They took time. Often, an exercise would point out something useful after I'd already
spent days takling a problem. Othertimes the exercises would simply point out an
alternative. They were helpful, but sometimes overwhelming. Might need to be shifted a
bit into a dedicated programming course to be taken before this class.

Statistic Value
Total Responses 14
 84

25. What would you recommend, if anything, to improve the

technical side of the semester project?
Text Response
Better explanations to the code and what it does.
I don't know
Just make sure that the software works on the computers ahead of time. I don't expect that
really being applicable to future semesters though.
Just get Unreal to work in the labs, please.
It would have been better if the Prof looked into the engine more to see if it would have
worked with the lab hopefully finding the problems earlier on
Give more in class demos, particularly on the more complex/difficult portions, and
include screenshots for them (at least for complex coding).
no
None
Maybe try to explain how to use the engine more broadly? Any type of structure to the
group projects would also probably help. Learning through experience is nice and all, but
throwing students at a relatively unknown engine and telling us to make literally any type
of game was broad. We got feedback on our milestones but we had to make those as well,
and as mentioned the exercises didn't always help. Creative freedom is great, but some
limitations could fuel creativity in addition to making things easier to manage.
Use unity for exercises
I suppose it's good as it is currently.
Choose a game engine that works on the lab computers.
giving more guidance
More time exploring how to make things work, and why things need to be done in certain
ways, and how to select when to use a blueprint system vs. creating fresh code, etc.
Points again to a new programming class.

Statistic Value
Total Responses 14
 85

26. What would you recommend, if anything, to improve the

teamwork aspect of the semester project?
Text Response
Have the team project be a specific type of game (3D first person, 2D platformer) so that
there would not be so many different bugs to work out in each project.
None
It might be nice to have students divide themselves into a subgroup and divide into
groups from there. This way you would have an even distribution of programmers,
writers, and artists on each team.
Nothing that I can think of. My group worked pretty well.
Allowing people to work in smaller groups if they wanted so that they didn't have to
work in groups and make games that they didn't enjoy
Make sure it is clear that when the class is to get into groups for the first time that they
know it is highly probable that those individuals will be one's group members (this
happened to my group but everything mostly worked out fine).
no
None
I'm not sure how you could improve teamwork between random classmates. More
guidelines as mentioned before could help, as teams could more accurately know and
divvy up what they had to do.
Nothing
Better help keep things organized from the start, give people the idea of the list of what
each person should do every week from the beginning so everyone is on track.
N/A
random assign
Having flexibilty to make massive changes as issues develop was an important aspect in
making the project more or less "successful". I can't think of much beyond that.

Statistic Value
Total Responses 14
 86

27. What topics do you feel should be covered in lecture?

Text Response
Coding concepts
We didn't really have lectures
Success of companies How to find work Current events Quality of life for game
designers Different components of game design within the industry
I would have loved to learn more about the different things we were doing inside of
Unreal.
The main aspects of important programming in video games, such as level design, GUIs,
and possible steps of interaction
A brief coding and/or modeling tutorial for anyone that somehow skipped CGT 215 or
241/340. Otherwise, just lecture on how to use various features of Unreal (or whatever
the game engine is) as well as how to think of a game idea/concept and/or the various
(but basic or "standard") gaming genres that could be used or made for the class.
programming and some design
Not sure
1. Clarifying/explaining/contextualizing lab work, 2. General game design principles, 3.
Maybe a little bit on how jobs in the industry work?
Unity
I'm not sure what else should be covered.
Unity development
we don't have lecture
explanations of technical aspects of using a game engine, and what's possible and how to
use it.

Statistic Value
Total Responses 14
 87

28. I prefer the lab-oriented format of the class to a traditional

lecture course:
# Answer Response %
Strongly
1 3 21%
Agree
2 Agree 4 29%
Somewhat
3 4 29%
Agree
Neither
4 Agree nor 0 0%
Disagree
Somewhat
5 3 21%
Disagree
6 Disagree 0 0%
Strongly
7 0 0%
Disagree
Total 14 100%

Statistic Value
Min Value 1
Max Value 5
Mean 2.71
Variance 2.07
Standard Deviation 1.44
Total Responses 14

29. I think the ideal distribution of lab work versus lecture for
this course should be:
Average Standard
# Answer Min Value Max Value
Value Deviation
1 Lecture 0.00 70.00 19.79 21.02
2 Lab 2.00 90.00 40.71 34.32
 88

30. I am confident with my game development skills:

# Answer Response %
Strongly
1 0 0%
Agree
2 Agree 2 14%
Somewhat
3 8 57%
Agree
Neither
4 Agree nor 2 14%
Disagree
Somewhat
5 0 0%
Disagree
6 Disagree 0 0%
Strongly
7 2 14%
Disagree
Total 14 100%

Statistic Value
Min Value 2
Max Value 7
Mean 3.57
Variance 2.42
Standard Deviation 1.55
Total Responses 14

31. I am confident with my Unreal Engine skills:

# Answer Response %
Strongly
1 0 0%
Agree
2 Agree 0 0%
Somewhat
3 6 43%
Agree
Neither
4 Agree nor 3 21%
Disagree
Somewhat
5 2 14%
Disagree
6 Disagree 1 7%
Strongly
7 2 14%
Disagree
Total 14 100%
 89

Statistic Value
Min Value 3
Max Value 7
Mean 4.29
Variance 2.22
Standard Deviation 1.49
Total Responses 14

32. I am now motivated to pursue game development:

# Answer Response %
Strongly
1 3 21%
Agree
2 Agree 3 21%
Somewhat
3 4 29%
Agree
Neither
4 Agree nor 1 7%
Disagree
Somewhat
5 1 7%
Disagree
6 Disagree 2 14%
Strongly
7 0 0%
Disagree
Total 14 100%

Statistic Value
Min Value 1
Max Value 6
Mean 3.00
Variance 2.92
Standard Deviation 1.71
Total Responses 14

33. Are you interested in taking the advanced course?

# Answer Response %
1 Yes 9 64%
2 No 5 36%
Total 14 100%
 90

Statistic Value
Min Value 1
Max Value 2
Mean 1.36
Variance 0.25
Standard Deviation 0.50
Total Responses 14

34. You had a good overall experience with the class:

# Answer Response %
Strongly
1 0 0%
Agree
2 Agree 7 50%
Somewhat
3 5 36%
Agree
Neither
4 Agree nor 0 0%
Disagree
Somewhat
5 0 0%
Disagree
6 Disagree 0 0%
Strongly
7 2 14%
Disagree
Total 14 100%

Statistic Value
Min Value 2
Max Value 7
Mean 3.07
Variance 2.99
Standard Deviation 1.73
Total Responses 14
 91

35. Why?
Text Response
Fun class, results are clear and straight forward
It was fun and exactly what I want to do with my life.
It was neat to be able to see what the other students brought to the class and speak with
other people that had the same interest as me.
I just really enjoyed how this class worked and what we really had done in the group
projects.
It was interesting learning a more modern engine that was a bit more complicated than
the rest.
I was able to learn how to make a game and face typical developing issues (particularly
with coding),, as well as work with a group to make a game, even if it was simple. I can
officially say I contributed to make a game.
we can do project at home
I like game designing
I've wanted to work on games, and this class let me, so that was expectedly enjoyable. It
could've been managed a bit better though, and my lack of experience in other areas like
modeling made things a bit rough here and there.
There was hardly any teaching, and the engine used in the labs was broken
It was good but sometimes it was hard to complete the exercises because something was
mistyped or what I was told to do wasn't correct so I had to get the problem fixed in order
to finish the exercise and do the next one.
They chose an engine that didn't function properly on the lab computers, causing me to
be unable to finish the exercises.
enjoyed
I actually found myself having fun while working on the project for this class. I
absolutely abhorred the web development class.

Statistic Value
Total Responses 14
 92

36. The technical issues in the class did not affect the
educational experience:
# Answer Response %
Strongly
1 0 0%
Agree
2 Agree 2 14%
Somewhat
3 1 7%
Agree
Neither
4 Agree nor 2 14%
Disagree
Somewhat
5 7 50%
Disagree
6 Disagree 0 0%
Strongly
7 2 14%
Disagree
Total 14 100%

Statistic Value
Min Value 2
Max Value 7
Mean 4.57
Variance 2.26
Standard Deviation 1.50
Total Responses 14

37. How well was the class taught?

# Answer Response %
1 Very Good 1 7%
2 Good 8 57%
3 Fair 3 21%
4 Poor 1 7%
5 Very Poor 1 7%
Total 14 100%

Statistic Value
Min Value 1
Max Value 5
Mean 2.50
Variance 1.04
Standard Deviation 1.02
Total Responses 14
 93

38. What advice do you have to improve the course?

Text Response
More coding lessons
Fix the technical issues in the labs. Make the exercise more streamlined
Put more emphasis on creating a solid base for learning and less on creating a finished
product. As corny as this sounds, this class should be somewhat like a nest, from which
the students can learn to fly on their own after it's over.
Make sure that the program works in the lab and make sure that the exercises don't have
as many issues with them.
Get more Unity Licenses and test out an engine in the lab before adding it to a course
More in class demos, especially for the introduction exercises and difficult coding
portions of an assignment. Stick to only one gaming engine, unless the other one(s) are
used for more than one or two assignment.
teaching programming
None
As said before, more guidelines and explanation would help. I would enjoy more talk on
game design and how to make games beyond the bare bones technical aspect (design is
somewhat opinion, but it has some generally accepted points; and I'm sure professional
games have a lot in common with how they are built and organized).
Use unity
Just again make sure the instructions are written out properly.
Use Unity, and actually teach game development.
none
Known issues have already been tackled, or are in progress. Hopefully the people at
Unreal will start taking more seriously the deployment of their program on University
computers, if they haven't already.

Statistic Value
Total Responses 14
 94

39. What would have helped you personally?

Text Response
More coding lessons
Better excercises
I would have really liked just some information on what and why I am doing the things I
am doing inside of Unreal.
If the Prof knew more on the engine
Screenshots for complex/difficult coding portions, especially for the last few
assignments. Being able to work on an assignment in lab rather than at home while still
using the same instructions in addition to being able to build a program through Unreal in
lab too.
.
None
What I said above would have helped. Getting behind on exercises was my own fault, but
it would've been harder if the explanations were clearer and I wasn't winging it on so
much of the group project.
Not using a broken engine
Not much really, didn't have many other problems.
If the professor chose a program that actually worked.
none
Getting a better understanding of how to master using the game engine. I still feel less
than competent in being an asset in a game development company.

Statistic Value
Total Responses 13
 95

40. Are there any other comments that you would like to make
about the course?
Text Response
More coding lessons
N/A
While there were sometimes occasions in which the instructions were unclear in the
assignments, I felt you did an excellent job of helping the other students when they had
issues.
The TA did a great job writing the course and exercises. Good job, Nick
No further comments other than what I had previously mentioned.
.
None
Everything I could say has been covered. Hopefully the next gaming course has some of
these things I wanted more of.
I regret taking this course
Not really.
This course was poorly run and an utter disappointment to myself and others.
nope
Fun, but tough at times. Really could use that programming course for those who want to
take it.

Statistic Value
Total Responses 13
 96

Appendix C Exercises
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249