=Video Game Design Using New-Age Development Processes, Tools, and Design=
'''Kyle D. Thompson, Da Vis C. Linder (Faculty Advisor – Anthony Varghese)
Department of Computer Science and Information Systems
University of Wisconsin – River Falls'''
===Abstract===
In the past, most video game design has involved two parts: choosing or building a custom game engine, and creating the game, including models, rules, logic, etc. While this still holds true, game engines that were not custom built were often limited in functionality. Also, a big part of a finished game's functional engine was added in the creation of the game. Recently, new tools have been developed that streamline game development by putting more reusable functionality into the game engine and adding an Integrated Development Environment/editor. These new game engines/editors allow new-age game design to be effective using Incremental Development, Collaborative and Extreme Programming, and other Agile Development techniques. The focus for this project was to develop a video game using Agile Development techniques with the modern, feature-full game development engine/editor Unity. In addition to exploring how video games and other real-time interactive 3D software can be developed rapidly and efficiently, the game developed for this project strives to break video game genre norms by realizing a novel game idea involving advanced physics, destruction, and realism with player-controlled food items in a grocery store.
==Introduction==
When the video game industry started, there were no game-specific development tools; games were developed with the same tools as any other software. Games accessed the hardware directly or used system functions to interface with input, graphics, sound, and other devices, resulting in code-heavy games with little reusability from game to game.
As software development moved towards Object-Oriented Programming (OOP), game development followed with the progression of code libraries to take care of reusable functionality needed to run a game, such as wrapping system functions, easing platform-specific setup. Libraries like these continued to be developed and started providing additional simple game functionalities, such as '''sprite management, graphics blitting, and collision detection''' between game objects. Regardless, games were still created mostly with code and graphic files, requiring frequent rebuilding to see the effects of changes to the code.
As the programming and processor power worlds evolved, the ability to develop and maintain Graphical User Interfaces (GUIs) connected to the data objects and the concepts of visually managing graphical, data-oriented, and UI-oriented resources grew and became usable for mainstream development[such as Cocoa]. As games evolved, the needs arose for more visual ways of building and putting together game resources. The game development field entered this domain with in-house tools that provided the visual management and editing necessary to develop parts of the games of the time, such as levels or character "skins". Many of these original tools (and some tools used to build modern games) are focused on the scope of the game's target features, play flow, and objectives, limiting them to genre.
With the spirit of the earlier reusable game development libraries and the power of visual game management and editing, modern game engines/editors have recently come about to provide the resources and tools needed to fully develop and manage game projects or other visual interactive software. Some tools with a broader design scope have come onto the market that inexpensively give independent developers, students, and other hobbyists the power to realize modern games and larger developers the tools to quickly prototype any game design concept. Our project was to explore game design and development using one particular offering of tools from this new age of game development, the Unity Engine[link to [http://www.unity3d.com http://www.unity3d.com], I guess].
==Visual Development==
Visual Development tools and environments are applications that feature interactive workspaces to visualize, manage, and modify the resources, properties, and object connection structures of a project in real-time, preventing the need to use fragile programming code to '''create, set up, interconnect, process, and display the project's object structure'''. These tools give the developer an added level of abstraction to the base libraries and resources, enabling easy set up and management of graphics rendering, physics simulation, sound playback, scripting (including game logic and artificial intelligence), animation, networking, etc. This removes the need for direct manipulation with low-level interfaces, while often still supporting this power if needed, which can help in the development of new tools.
Through using Unity, we experienced the benefits of visually connecting game objects with built-in components and custom-written component scripts to create complex objects and chains of communication to keep our game running smoothly. We also discovered that using and building small, single-purpose scripts and attaching them to objects not only made the creation of useful functionality easy to develop and manage, but also created components that can be painlessly modified, reconfigured, and reused in our project or completely different projects, just like the components and scripts that Unity already encompasses. Being able to visually connect and tweak objects and components helped subconsciously maintain the principles of OOP and provide the tools needed to plan, develop, and maintain the project with speed and agility.
==Agile Development==
Agile Development is a software development model that focuses the development of a project to smaller incremental planning and development stages, enabling concise functionalities to be implemented and tested piece by piece, building up the overall project. This '''"build, test, tweak, repeat"''' process promotes leaner phases in development and facilitates quick evaluation of progress and apt project direction guidance. Agile techniques empower and promote development teams to fix and modify the interconnected parts of the project in a cooperative manner, while requiring a workplace with a highly collaborative environment.
The Agile model is well suited for '''Rapid Application Development''' (RAD) in that prototypes can be built very quickly (sometime in a matter of hours) enabling hobbyists and independent developers, as well as large developers, to continue developing prototypes into full-scale finished products. The use of agile techniques and the proliferation of visual tools ensures that today’s hobbyists can become tomorrow’s leading game developers.
We found through our development experience that the principles of the Agile model and the fact that we are a team of two allowed us to have short development phases, especially when Extreme Programming with real-time collaborative text editing, which essentially resulted in phases equal to our development sessions. Piecing-in functionality to different aspects of our project gave us the means to incrementally test development aspects and continue building in additional features, as well as equipping us with the options to easily go back and reuse or continue work on other portions of code without drastically affecting the entire project.
==Our Development Experience==
===The Unity of Agility and Visuality===
This project consisted of using the Unity game development engine and environment to explore creating a game concept from scratch. Unity is a modern Visual Development tool designed to create video games and other interactive graphical applications, with extended game resources and visual editing and management abilities. This provided us with an architecture that similar in nature to both a high-end 3D modeling and animation program and a typical interactive 2D animation tool, with a drag and drop functionality that helped us start and build our game design concept visually by connecting and adding in features further and further into the development of the game. Unity also features the abilities to view the scene and resources of a game in its set-up state or at any point of game execution, while being able to adjust any property of connection in real-time, helping us "put the pieces together" creatively and quickly while actively play-testing our game, proving that "what you see is what you play".
Unity supports a good selection of scripting languages combined with Unity's one-to-one editor component-to-OOP object API as well as the powerful OOP structures and functionalities from the .NET framework. These provided us with a solid starting point to create functionalities through scripting using a language to the complexity of our choice. For the sake of development time, we chose the simpler and more familiar choice, Unity's implementation of JavaScript to create the features of our game.
Like some non-game development tools, Unity stores objects in the scene of the editor and the connections to their resources and each other as direct serialized data[like Interface Builder], providing the extra speed and reliability of objects being set up correctly (or visually showing problems in the editor) needed for a video game.
One factor that we found invaluable is that the Unity developers and community provide extremely helpful resources on Unity development with active forums providing quick answers and discussions on problems, development ideas, and future Unity ideas; fairly precise documentation of editor and scripting concepts; and personal technical support with quick turn-arounds for both paid licensees and users giving it a free trial. This gave us an active resource unlike like most other more-open products we have dealt with.
===Building the Grocery Store===
We took steps to bring our original game concept from an idea to the developed project by building the groundwork through the stages of initial design, choosing a development engine, selecting a development model, and setting up development hardware, then continuing through creating the prototype concept within Unity and iteratively adding in functionalities and brainstorming where to go next as we progressed through development towards our goals.
We selected the Agile Development model because it seemed very appropriate when combined with a visual development environment. To utilize this model we held weekly meetings for the project and structured our development cycles around this schedule. Through weekly project goals and progress analysis, we facilitated incremental development and charted new objectives as we attained old ones. We also explored Extreme Programming by working on essential chunks of code in the game with a collaborative real-time text editor, allowing us to both see the same text document on our screens and edit it simultaneously seeing changes instantly, regardless whether we were sitting side-by-side or across the city. We also use the same Extreme Programming tools and principles for writing documentation and the poster for this project, along with using a wiki to track important project ideas and notes.
As with many other projects that have multiple developers, we used the Concurrent Versioning System (CVS) to help source control our project. Although Unity does not easily support movement of pieces of the project, we used the '''project maintainer paradigm''' in which one of us kept up an up-to-date version of the project by importing and connecting updated resources. Although tricky at first, this process, along with the ability to package up a whole up-to-date project and distribute to each developer as a building point proved very necessary when working collaboratively on this project.
In the virtual grocery store, the playable characters are objects of food set up with built-in components for material, mesh, and physics associations and scripts we modified and custom built to allow the character move around the store and collide with other food objects dealing damage and obtaining game goals. This is done through attached scripts and associated behaviors controlling individual properties when applying an object's physics, damage capacities, shaders/lighting effects, and various other properties and states. We also wrote some simple scripts of the type that likely need to be built or reworked for games of different flows, such as our game objective, level creation, or character spawning scipts.
Even though the base tools in Unity have the power to develop flexible sets of rules and game concepts to realize most game ideas, we had to reach outside the boundaries occasionally to explore and create our own functionalities to build the game to our tastes. One simple feature we built was using controlled random numbers by optionally giving a random number generator the same random seeds to obtain the same results. We used this to build parts of the level in a realistic manner without having to set things up by hand and giving us the ability to dynamically create levels.
Another feature developed was our own custom real-time damage calculation. As characters move throughout the grocery store and collide with parts of the level or other characters, a script runs to calculate if and to what extent each character takes damage by processing the collision velocity and angle; the character's mass; the collided object's "bluntness", "sharpness", and "pointiness"; the region collided with and damage type and region combination factors; and the character's resilience (damage prevention), toughness (damage reduction), and fatiguing levels, all damaging both the surface and the body of each character individually. Unity provided its highly useful physics and collision system; we built our damage system on top of it in a way that could be quickly plugged into many other Unity projects.
In addition to calculating a damage total, we envisioned characters sustaining injuries by showing visual damage effects painted onto the object's texture rather than having the player observe a typical health meter. We built this system from a Unity example script showing how to apply texture decals to a mesh in real-time and extended it to take values from the damage calculation system and settings for decal size, opacity, shader material, and brush for each damage type and both surface damage and broken-into body damage to paint damage effects on at each damaging collision. Again, Unity provided the API to access and control the properties and resources in order to build the system the way we wanted.
==Summary==
Combining Visual Development tools and Agile Development tools and techniques proved very useful for our game development project as it provided us the abilities to develop software in less time and more concisely by utilizing a powerful editor and framework for needed features. This approach seems very useful for many types of modern software development and may become the basis of all software development in the future. Our project took advantage of these tool and project management advances and allowed us to develop a game advanced in some respects and gave us the experience of developing a real video game project.
===Future Direction===
Our current direction with the project is to continue exploring the Visual Development paradigm by completing development of our game with Unity. The knowledge gained from our research will give us the basic building blocks to understand video game design and development in addition to giving us the experience to plan and create further projects as independent developers or game project managers. Another avenue we wish to explore is to compare and contrast other development software packages beyond Unity to strengthen our development prowess and understand the scope of tools on the market.
Regardless, we would like to finish game to a level of playability to make it possible to distribute for free or as inexpensive shareware and continue building game features we have envisioned such as damage painting on the floor of the store to show damage pieces and liquids from food with appropriate physics effects, real-time mesh deformation along with the damage texture paining, more play mode and level options, and network and Internet playability.
===Final Thoughts===
Through the development of our game we have learned a large variety of things to remember when starting or working on a development project. Having the right hardware for the task at hand is a top priority when starting new projects. Proper project planning and time management is critical throughout all the stages of development and play pivotal parts in the success of development cycles. There are many challenges to face when working on a project and although difficult at times, the overall process can be very rewarding.
===References===
"Agile software development." Wikipedia, the free encyclopedia. 7 Apr 2007. Wikimedia Foundation. 2 Apr 2007. <http://en.wikipedia.org/wiki/http://en.wikipedia.org/wiki/Agile_software_development>.
"CryENGINE™ 2 Specifications v1.3." Crytek Technology. Crytek GmbH. 7 Apr 2007 <http://crytek.com/technology/index.php?sx=eng2>.
"GarageGames." GarageGames. GarageGames.com. 7 Apr 2007 <http://www.garagegames.com/>.
"Game development tool." Wikipedia, the free encyclopedia. 7 Apr 2007. Wikimedia Foundation. 28 Mar 2007. <http://en.wikipedia.org/wiki/Game_development_tool>.
"Game engine." Wikipedia, the free encyclopedia. 7 Apr 2007. Wikimedia Foundation. 7 Apr 2007. <http://en.wikipedia.org/wiki/Game_engine>.
"Powered By Unreal Technology." Powered By Unreal Technology. Epic Games Inc. 7 Apr 2007 <http://www.unrealtechnology.com/html/homefold/home.shtml>.
"Simple DirectMedia Layer." Simple DirectMedia Layer. 7 Apr 2007 <http://www.libsdl.org/>.
"Source Licensing." Valve. Valve Corporation. 7 Apr 2007 <http://www.valvesoftware.com/sourcelicense/enginefeatures.htm>.
"Tech Whitepaper." Over the Edge. Over The Edge Entertainment. 3 Dec 2004 <http://www.otee.dk/site/Tech/frameset.html>.
"UNITY: Game Development Tool." UNITY: Game Development Tool. Over The Edge Entertainment. 7 Apr 2007 <http://www.unity3d.com/>.
===Acknowledgments===
We would like to thank Dr. Anthony Varghese for allowing to take on this project as an independent study and teaching us the basics of OpenGL programming. Also, we would like to show our gratitude to Andy Thompson for creating the 3D models needed for our game project.