We submitted a few proposals for next year’s GDC here at Insomniac. I’d like to share those with you. We’d love to get any feedback you might have so that we could make them as interesting and useful as possible! (If they are accepted by the GDC committee.)
Culture Shock: User-Research on Resistance 3
Speakers: Bill Fulton (Founder, Ronin User Experience); Drew Murray (Creative Director, Insomniac Games)
Track: Game Design
Format: 60-Minute Lecture
After participating in formal usability tests near the end of Resistance 2 production, Insomniac Games began a fundamental shift in how we make games. While Insomniac has always been focused on making great games – and has a long history of doing so – we’ve relied largely on our gut-feelings of what’s going to be fun, utilizing limited playtesting near the end of production to find and fix major problems. Formal usability testing on Resistance 2 showed us that there was a surprising and often painful gap between how we, the developers, played and understood the game and how typical gamers did. Based on the difficulties we saw playing having in our Resistance 2 usability tests, Insomniac as a company decided to move beyond paying lip-service to user-research and fully committed to systematically integrating it throughout the Resistance 3 development cycle, not just near the end.
What Testing Methods Worked? We used many types of user-research over the course of Resistance 3 production – external RITE usability tests, weekly company-wide playtests, informal one-on-one internal playtests, large-scale external playtests, and other methods. We’ll discuss the pros and cons of the different methods we used, the different information we were able to get from different kinds of testing, and the realities of financial and time costs of each.
Overcoming Culture Shock. There was more than a small amount of opposition on the team to the amount of user-research that we did on Resistance 3. User-research can put a tremendous burden on all members of the team, whether it’s running the tests, gathering and analyzing data, quickly iterating to respond to feedback, or just carving out an hour or two a week to actually play the game! We’ll discuss our experiences on Resistance 3, ways to get your team excited about doing user-research on your game, and how to handle common team complaints.
Did It Work? As we ship Resistance 3 (on the day this talk is being submitted!), we’ll examine whether we accomplished our goal with use-research for the game and some of the specific – and sometimes very significant – changes that we made to the game based on the findings. We’ll also talk about some of the things that didn’t work as well as we’d hoped with our testing methods for Resistance 3, and what we plan to do differently in the future.
Attendees of this session will get an insider’s view to the sometimes-bumpy road that Insomniac Games has traveled over the past three-and-a-half years as we’ve revamped our game-development process to focus on frequent and consistent user-research. Different user-research methods will be illustrated by specific examples from Resistance 3, such as videos of the RITE testing we did for core controls and aim-assist, and graphs created to track how the rating-scores assigned by playtesters for different levels and features trended over production. Attendees will also learn about common pitfalls and how to overcome them, and how to convince a team that user-research is an invaluable tool for improving your game.
Using Middleware With a Custom Job Manager
Speaker: Chris Kosanovich (Engine Programmer, Insomniac Games)
Format: 60-Minute Lecture
A year and a half ago we started work on a brand new engine at Insomniac Games. We decided to start from scratch on both tech and tools. Because we have aggressive timelines for games using this engine we made choices to use middleware where we had previously developed custom solutions. Among the middleware vendors we are using is Havok, however one of the first issues we found with integrating their systems into our engine is that on the ps3 we don’t use spurs and instead have rolled our own job manager in house that is more tailored to what we need. This has caused all sorts of issues from simple things like having to port the havok spu elfs to our custom spu modules, to dealing with cloth’s use of overlay tables and finding a solution for that.
My talk will focus on the challenges (like those listed) that we faced and how we dealt with them. I will detail what benefits we are seeing and what we expect to see on future titles.
This will be valuable to others thinking of using middleware in conjunction with a custom core system, or something like Sony’s WWS job manager.
Developing Imperfect Software, how to prepare for development pipeline failure
Speakers: Ronald Pieket (Senior Engine Programmer, Insomniac Games)
Format: 60-Minute Lecture
Computer game software development, more than any other kind of software development, relies on the usage of software that is itself under development.
In this talk I will assume a common scenario: the game content is developed in parallel with the game technology itself. Game technology includes the game executable as well as a custom content production pipeline.
Development team members rely on up-to-date versions of the game technology. And because this technology is itself in development, it will fail regularly.
In a medium to large development team, day to day breakage of the game technology can lead to productivity loss. The larger the team is, the greater the potential loss.
In this talk I will assume that development teams have already taken steps to minimize breakage. I will assert that it is not practical to prevent all breakage. The talk is about measures that you can take in your code and pipeline, to reduce the impact of breakage, and minimize productivity loss.
I will briefly discuss my experience with previous attempts to address this issue, including unit testing, code vetting, peer review, and controlled version distribution. They are valuable but have drawbacks.
I will propose a three way approach: resilience, reversion, and reporting.
(1) Resilience: avoid “perfect or nothing” implementation. Don’t abort runtime execution for errors that can be fixed up. (Use automated reports to avoid issues going stale – more under “reporting”) Verify asset data upon loading, and be tolerant of data format differences. (I will explain options) In tools, prevent loss of work by adopting a client-server architecture. (I will explain what we have done at Insomniac)
(2) Reversion: offer a simple mechanism to revert to earlier versions of everything that can break, including executables and asset data. Revision control systems and package installers have shortcomings. (I will explain what they are) Code/data version dependencies make reversion harder. (I will explain how to avoid them)
(3) Reporting: an assertion dialog and stack trace on the screen of an artist has a long way to travel. It interrupts their work flow, and if it is “skippable”, it is likely to get ignored. I will propose an automated remote error reporting system and database. (I have a lot of detail available)
In order to develop the next hit game, we must ensure that during development, the game and other development software not only works well, but also fails well.
Designs: Ideas with Intent. Realizing What You Want to Solve and then Applying the Best Solution.
Speakers: Mike Ellis (Design Director, Insomniac Games)
Format: 60-Minute Lecture
In the world of game design the coolest idea is king. However, as an industry, game development has very few processes for creating and developing ideas that can be used to spawn the next smash hit. All too often lots of ‘loose’ ideas are smashed together and fail to make a complimentary and well rounded design.
This session aims to help change that by demonstrating that great designs aren’t simply ideas, but ‘ideas with intent’. That is, design solutions that not only are cool, but are crafted to solve very particular problems that have been identified and communicated.
The session will show the audience the four steps to designing with intent (Defining, Creating, Evaluating and Choosing) and demonstrate several techniques (Intent Statements, Goal Summaries, Defining Conditions and Parameters, Conversation Framing and Keeping Each Other Honest) that can be used by designers in order to ensure that they are communicating their intent. It will also discuss why communicating the intent of your ideas is an important and effective weapon for leveraging the power of the team and generating increased buy-in.
Attendees will walk away with an appreciation of why designs are more important than ideas and be in possession of several techniques that they can instantly apply to their work upon returning to the studio.
Math and Physics for Game Programmers
Speakers: Erin Catto (Principal Software Engineer, Blizzard Entertainment); Erwin Coumans (Principal Physics Engineer, Advanced Micro Devices); Gino van den Bergen (Owner, DTECTA); Glenn Fiedler (Senior Staff Online Game Programmer, Sony Computer Entertainment); Graham Rhodes (Senior Software Engineer, Applied Research Assoc., Inc.); Jim Van Verth (Engine Programmer, Insomniac Games); John O’Brien (Senior Gameplay Programmer, Insomniac Games); Mike Acton (Engine Director, Insomniac Games); Richard Tonge (Senior software engineer, NVIDIA Corporation); Squirrel Eiserloh (Director, TrueThought); Takahiro Harada (Researcher, AMD);
Format: Two-Day Tutorial
As the complexity of games as increased, so has the knowledge needed to create them. Creating the latest code for graphics, animation, physical simulation, even some extent artificial intelligence, requires greater knowledge of the necessary mathematical underpinnings than ever before. And of the fields described above, one of the most rapidly growing is physical simulation, as shown by discussion boards, the latest games, and a recent burst of articles and papers. Creating such a simulation may appear to be a daunting task, but it is possible with the right background.
This two-day tutorial continues and expands the tradition of both the “Math for Programmers” and “Physics for Programmers” tutorials by bringing together some of the best presenters in both gaming math and physics. Over the course of two days they will get programmers up to speed in general 3D math, and then deepen their knowledge by focusing in on the topic of physical simulation.
Day One of the tutorial (Math for Programmers) will concentrate on the core mathematics necessary for sophisticated 3D graphics and interactive physical simulations. The day will focus on the issues of 3D game development important to programmers and includes programming guidance throughout. Topics include affine transformations, quaternion algebra, computational geometry, curves and interpolation, math for game AI, and optimized data-oriented design for mathematical operations.
Day Two of the tutorial (Physics for Programmers) will provide a toolbox of techniques for programmers interested in creating physics engines, with references and links for those looking for more information. The focus of the course is to study various pieces of the simulation pipeline and show how problems along the way can be solved and optimized using standard 3D mathematical concepts and engineering know-how. Topics include integration of a physics engine into a game, rigid body solvers, collision detection and contact resolution, physics on mixed CPU-GPU systems, rigid body destruction, and networking for physics programmers. Sample code libraries and examples are provided.
Game Tools as a WebApp: Lessons from Insomniac’s Next-Gen Tools and Engine
Speaker: Mike Acton (Engine Director, Insomniac Games)
Format: 60-Minute Lecture
Insomniac, like many developers, has traditionally treated development tools as a second-class development effort. While we have had dedicated Tools programmers for many years, very little effort was put into the overall user experience and runtime performance was always valued over development effort. This resulted in a systematic increase in development cost and an entire “Engine Economy” based on brute-force effort. Two years ago, we decided to tackle this problem head-on. The result is an entirely new suite of tools, written from the ground up to fundamentally change the way we work as a studio.
It was also clear that the world was changing. The explosion of web-based enterprise applications, fully-web enabled mobile devices (like the iPhone and iPad) and browser-based gaming sent a clear signal that the era of native applications living in a sandbox was over. Not just for games, but also for the tools we use to develop games. We felt this was an opportunity to make a strategic change that would position us much better and net us valuable experience for the inevitable changes to operating systems, development tools and user expectations.
This is the story of our experience so far.The first game Insomniac will ship on these tools is Overstrike. We will share our most significant choices and the costs of those choices. We will suggest alternatives where we feel that better results can still be achieved. And we will share details of the technical architecture of the new tools suite.
Details such as:
Usability is not random. We needed first-class information to develop first-class tools. We set up a formal usability practice without a lab or additional budget using a single PC. We will also share specific, novel tools features such as our “neighbor” and “tile” mode which allowed us to increase production time on common tasks by as much as 20x.
The choice to go webapp. The initial version of the tools was not web-based. It was a native application which used Flash for the front-end. This model was not significantly improved over the traditional native model and introduced the same data complexities. Webapp tools allowed us to not only take advantage of many available development tools, it forced a clean separation of UI and back-end data.
Client/Local-server model. One of the concerns of browser-based tools is adding latency. We largely solved this issue by running a mongoose-based web server local to each machine.
Additional details. We will also share our experience with allowing custom tools and UI development by non-tools programmers. Our take on the Flash vs. HTML5 debate. Details of integrating a native engine. And browser and security workarounds.
We’ll share enough about how we made our tools and why so that you could begin to duplicate the process. We’ll share why we made the choices we made so that you can justify the effort and search for reasonable alternatives. And we’ll share where we went wrong so that you can avoid the same costly mistakes.
Developing Animation Tools Using Web-Based Technologies
Speaker: Giacomino Veltri (Engine Programmer, Insomniac Games)
Format: 60-Minute Lecture
The goal of any game toolset is to provide content creators with the ability to access and tweak a wide variety of in-game parameters. Providing high-level access to base features often leads to an almost unmaintainable mish-mash of low-level systems code and high-level user interface code. Fortunately, the separation of user interfaces from implementations is a problem that has already been largely addressed by the Web.
Browsers are becoming more and more ubiquitous and are showing up on more and more hardware devices. Thus it seems only natural to make browser-based game tools. This presentation will break down how the task of creating an animation set for an in-game character can be done using a browser-based solution.
However, the devil is in the details, and this presentation will discuss some of these details that need to be taken into consideration when deciding to make browser-based game tools. Some of the advantages include:
• Separates high-level user interface code from low-level code
• Portable to a wide variety of platforms
• Lots of custom controls already created and available
• Can easily and quickly prototype user interfaces (no compile step; just reload the web page)
• It is easy to create custom controls with custom graphics
• Stability; crash-inducing bugs in the user interface do not necessarily cause data loss
Other things to consider are:
• When to chose the right tool (HTML5 canvas vs. Flash, and so on)
• UI design challenges
• Debugging (and there are some silent failures)
• What interface should one use to communicate with the low-level code?
• What will content creators think of this style of tool?
In conclusion, we hope that by creating browser-based tools, we provide our users with a richer and flexible user interface to create the games they want to make.
It Stinks and I Don’t Like It: Making a Better Engine Experience At Insomniac Games
Speaker: Sean Ahern (Information Architect, Insomniac Games)
Format: 60-Minute Lecture
Video game development has progressed significantly over the years – from punch cards and user made tools to enterprise level applications. While the technology that we use on a daily basis has changed significantly, can we really say that the experience of creating games has improved as well?
With each jump in console technology, we push the limits of both a studio’s budget, along with the amazing content that we can create utilizing the tools at our disposal. Studios are constantly on the look-out for the next best tech, middleware, or ideas to help make their next title a reality (and success). With licensed tech and often-times even proprietary software, the User Experience is frequently viewed as a second class-citizen when efficiency and deadlines are in the fore-front.
At Insomniac Games, we’ve decided to make the User Experience of our tools a priority. By leveraging traditional engine programming with web application technology, Insomniac Games has created their new engine from the ground up with a focus on the User Experience.
In this lecture, Sean Ahern, Information Architect for Insomniac Games, addresses how User Experience has helped lead the development of their new engine and its’ features.
Always Online: Network Systems in Insomniac Games’ Overstrike
Speakers: Peter Kao (Senior Gameplay Programmer, Insomniac Games)
Format: 60-Minute Lecture
Overstrike is an upcoming four-player, cross-platform action title from Insomniac Games, supporting online play. Getting Overstrike online required a fundamental shift in the studio’s development approach, making networking an integral part of the development process. This session will establish our ‘always online’ programming philosophy and provide a comprehensive overview of the network technologies used to support that goal.
On Overstrike, we are all network programmers. Each team member is responsible for implementing and debugging the network sync implementation of his or her feature. Adopting this development approach has reduced encounters with “it works offline” bugs, the online gaming equivalent of the classic “it works on my machine”.
High-level network APIs are always available in Overstrike—even when running without a network connection—and game state changes use the same interface in all modes. State changes are deferred by default; this programming model presents the programmer with a consistent interface and looser timing guarantees, reducing the inevitable differences between online and offline behavior.
We will present Insomniac’s high-level synchronization system, called SyncHost. This system provides ‘synced field’ feature which may be familiar to attendees. SyncHost has a number of other novel features which will be of interest, including a synced object allocation system, and the ability to send updates on an individual field. SyncHost is very loosely coupled to the network, and we will explain how this loose coupling enables the common interface between online and offline modes.
We will also present Insomniac’s synced components, which leverage synced fields to provide a network-centric complement to the popular component-based update systems appearing lately. As an example, we will show how synced components are used to implement state machines that sync across the network. Our approach uses synced fields to share transition data among clients, but allows each client to apply that data in a way that results in the best player experience.
The discussion of synced state machines will introduce our last syncing primitive, called the MessageInstance, which is a flexible message passing system used to provide non-deterministic updates to long running states. This interface transmits data defined by key-value pairs, and supports compression and querying if a value is present. The query technique leads to code-sharing opportunities that are not available with more traditional network models of sending an entire pre-defined packet of data, usually expressed as a C-style structure.
Overall, this presentation will give attendees a clear and complete picture of how robust networking technologies form a fundamental part of the development of Overstrike.