Home    General Programming    Artificial Intelligence    Math    Physics    Graphics    Networking    Audio Programming   
Audio/Visual Design    Game Design    Production    Business of Games    Game Studies    Conferences    Schools    Contact   
State of the Industry
Architecture
State Machines
Learning
Scripting
A* pathfinding
Pathfinding / Movement
Group Movement
Group Cooperation
Strategy / Tactical
Animation Control
Camera Control
Randomness
Player Prediction
Fuzzy Logic
Neural Nets
Genetic Algorithms
Natural Language
Tips and Advice
Tools and Libraries
Genre: RTS / Strategy
Genre: RPG / Adventure
Genre: FPS / Action
Genre: Racing
Genre: Sports
Genre: Board Games
Middleware
Open Source
All Articles
Game Programming Gems
Game Programming Gems 2
Game Programming Gems 3
Game Programming Gems 4
Game Programming Gems 5
Game Programming Gems 6
Game Programming Gems 7
AI Game Programming Wisdom
AI Game Programming Wisdom 2
AI Game Programming Wisdom 3
AI Game Programming Wisdom 4
AI Summit GDC 2009
GPU Gems
GPU Gems 2
GPU Gems 3
ShaderX
ShaderX2
ShaderX3
ShaderX4
ShaderX5
Massively Multiplayer Game Development
Massively Multiplayer Game Development 2
Secrets of the Game Business
Introduction to Game Development
GDC Proceedings
Game Developer Magazine
Gamasutra


Artificial Intelligence: Scripting and Data-Driven Techniques


Custom Tool Design for Game AI

P.J. Snavely (Sony Computer Entertainment America)
AI Game Programming Wisdom 3, 2006.
Abstract: Artificial intelligence systems in games have become so complex that often one engineer cannot write the entire structure alone. Using the Basketball Artificial Intelligence Tool (BAiT) we were able to integrate the artificial intelligence for NBA 2007 based entirely upon designer data entry and manipulation. While this approach has many positives there are also some drawbacks to implementing a system like this. There are also some necessary precautions that one should take before even attempting this process.

Scripting Your Way to Advanced AI

Alistair Doulin (Auran Games)
AI Game Programming Wisdom 4, 2008.
Abstract: Using script to empower designers with the ability to create advanced AI allows for more natural and specialized AI behaviors. This article discusses the best practices for achieving this using GameMonkey Script and gives an example of its usage in Battlestar Galactica for Xbox Live Arcade.

Opinion Systems

Adam Russell (Lionhead Studios)
AI Game Programming Wisdom 3, 2006.
Abstract: Modeling the formation and effect of opinions about the player character in a simulated social environment is a difficult problem for game AI, but one increasingly worth tackling. This article discusses some of the wisdom gained during the construction of perhaps the most complex opinion system ever seen in a commercial game, that of Lionhead Studios' Fable.

An Analysis of Far Cry: Instincts' Anchor System

Eric Martel (Ubisoft Montreal)
AI Game Programming Wisdom 3, 2006.
Abstract: An overview of the anchor system used in Far Cry Instincts to control dynamic cut-scenes and specific character reactions. This article explains a few choices made when the system was designed and then turns into a quick post-mortem style review of the system. Programmers working on a dynamic cut-scene system should find pertinent information that will allow them to build a better and more flexible system.

Creating a Visual Scripting System

Matthew McNaughton and Thomas Roy (University of Alberta)
AI Game Programming Wisdom 3, 2006.
Abstract: Scripting is frequently used to implement the story-related behavior of characters and other objects in a game. However, writing scripts can be time-consuming and difficult for the game designers responsible for conceiving of and implementing the story. We introduce a powerful, extensible, and expressive visual scripting framework to solve these problems, with a sample implementation. The framework works with any existing scripting language in any game. We used the ideas in this article to develop ScriptEase, a visual scripting tool, and have used it in several successful case studies where 10th grade students developed scripted game modules for Neverwinter Nights.

Intelligent Story Direction in the Interactive Drama Architecture

Brian Magerko (Michigan State University)
AI Game Programming Wisdom 3, 2006.
Abstract: Interactive drama is a new field of entertainment that attempts to give the player a dramatic situation that is tailored towards their interaction with the storyworld. A particular technique for creating interactive drama is the use of an automated story director, an intelligent agent that is responsible for managing the performance of synthetic characters in response to authored story content and player actions in the world. This article addresses some of the issues with using a story director, and introduces the Interactive Drama Architecture as a case study for story direction in a general architecture.

Dynamic Scripting

Pieter Spronck (Universiteit Maastricht, The Netherlands)
AI Game Programming Wisdom 3, 2006.
Abstract: Dynamic scripting is a technique that can be used to adapt the behavior of NPCs during gameplay. It creates scripts on the fly by extracting rules from a rulebase according to probabilities that are derived from weights that are associated with each rule. The weights adapt to reflect the performance of the scripts that are generated, so that rules that are consistently associated with the best scripts will quickly develop large weights and be selected more frequently. Dynamic scripting has been successfully applied to a wide range of genres and has been validated experimentally in RTS games and RPGs.

Scripting Language Survey

Diego Garc�s (FX Interactive)
Game Programming Gems 6, 2006.

Binding C/C++ Objects to Lua

Waldemar Celes (PUC-Rio), Luiz Henrique de Figueiredo (Institute for Pure and Applied Mathematics), Roberto Ierusalimschy (PUC-Rio)
Game Programming Gems 6, 2006.

Programming Advanced Control Mechanisms with Lua Coroutines

Waldemar Celes (PUC-Rio), Luiz Henrique de Figueiredo (Institute for Pure and Applied Mathematics), Roberto Ierusalimschy (PUC-Rio)
Game Programming Gems 6, 2006.

Managing High-Level Script Execution Within Multithreaded Environments

S�bastien Schertenleib (Swiss Federal Institute of Technology)
Game Programming Gems 6, 2006.

Building Lua into Games

Matthew Harmen (eV Interative Corporation)
Game Programming Gems 5, 2005.

Massively Multiplayer Scripting Systems

Jon Parise (Electronic Arts)
Massively Multiplayer Game Development 2, 2005.

Optimized Script Execution

Alexander Herz (Lionhead Studios Ltd.)
AI Game Programming Wisdom 2, 2003.
Abstract: The slow speed with which script languages are executed (compared to native code) places many limitations on a script language's potential applications. Previously only infrequently executed code placed outside of the game's inner loops has been deemed suitable for scripting, and for this reason script languages have typically only been used for story telling or customizable event-handling purposes.

Using optimization techniques presented in this article, it possible to increase script execution efficiency to near-native performance levels, enabling the use of scripting in the game's core logic, or even in a high performance 3D rendering system. The flexibility gained from switching to script-based logic means that even modifying a program's innermost mechanics is trivial, and does not come with the performance penalties one would expect.

Three stages of script execution are individually examined, and optimizations for each are presented. The techniques and principles presented can be easily applied to any existing scripting engine.

Advanced Script Debugging

Alexander Herz (Lionhead Studios Ltd.)
AI Game Programming Wisdom 2, 2003.
Abstract: Poor or missing script debugging facilities are among the principal reasons for scripts not being fully exploited in a development environment. Often, errors encountered during script execution result in crashes of the game or a "screen of death" style representation of the virtual machine's internal state just after the crash has occured.

In-depth knowledge of the virtual machine is required to interpret such information, and often the virtual machine's source code needs to be examined in order to identify the problem, which may have been caused by a virtual machine command executed long before the crash. Because all external developers (including the mod community) and most in-house script programmers lack this in-depth information, they will restrict their programming style to simple constructs that can be fixed using a trial and error process in case of a problem. Therefore even the most powerful script languages are doomed to be misused if they do not support proper debugging mechanisms.

This article shows how to incorporate known debugging capabilities from common development environments into your script system, giving your script designers and the mod community the ability to create complex scripts and use the language to its full extent, while also shortening the development period because of improved debugging capabilities for scripts.

Adding Error Reporting to Scripting Languages

Jeff Orkin (Monolith Studios)
AI Game Programming Wisdom 2, 2003.
Abstract: Custom scripting languages are a controversial game development tool. Scripting languages empower non-programmers by moving game AI logic out of the C++ code. While this empowerment certainly comes with some risks, the benefits are that additional team members can create behaviors, designers can tweak AI more directly, and the AI logic is more accessible to the mod community. The most common complaint about scripting languages is that they are difficult to debug. This concern is exacerbated if non-programmers intend to write scripts. If the scripting language compiler or interpreter only gives feedback like "syntax error," non-programmers are not going to get very far. Fortunately, this problem is easily solved. The same techniques used to define the grammar of valid syntax can be used to identify and report scripting errors in plain English. This article describes how to harness the power of Lex and Yacc to generate meaningful errors when compiling scripts. The article includes C++, Lex, and Yacc code for a simplistic language called Simple.

Empowering Designers: Defining Fuzzy Logic Behavior through Excel-Based Spreadsheets

P.J. Snavely (Sony Computer Entertainment America)
AI Game Programming Wisdom 2, 2003.
Abstract: Putting game development back into the hands of the game's designers is critical to keeping a project on schedule. How does that happen? What is the easiest way to let a game designer work on their own with a minimum amount of interaction from a technical source? Using Visual Basic for Applications and some basic applications, it is possible to design an interface which does both of these things, as well as having the added benefit of letting finished code stay finished.

A Modular Camera Architecture for Intelligent Control

Sandeep Kharkar (Microsoft Corporation)
AI Game Programming Wisdom 2, 2003.
Abstract: Cameras play a vital role in the user experience of any game. A robust camera solution can make the difference between a game that is awkward to play and a game that plays smoothly and feels great. Unfortunately, cameras tend to be a low priority item in many game development schedules and the effort is limited to the point where the cameras stop being a nuisance. One of the reasons that the efforts stop early is the lack of a solid architecture that allows rapid, data driven experimentation with camera behaviors.

This article presents a component based camera architecture that allows non-programmers to take over the development of cameras at the point where they make the transition between technical coding and creative effort. The architecture will demonstrate the use of common AI techniques to enhance the robustness and creativity of the camera solution for any game. The techniques presented in the article will primarily benefit games that have a third-person perspective, but will also provide useful tips for other types of games.

Creating a �Safe Sandbox� for Game Scripting

Matthew Walker (NCsoft Corporation)
Massively Multiplayer Game Development, 2003.

Precise Game Event Broadcasting with Python

Matthew Walker (NCsoft Corporation)
Massively Multiplayer Game Development, 2003.

Relational Database Management Systems Primer

Jay Lee (NCsoft Corporation)
Massively Multiplayer Game Development, 2003.

Leveraging Relational Database Management Systems to Data-Drive MMP Gameplay

Jay Lee (NCsoft Corporation)
Massively Multiplayer Game Development, 2003.

Data-Driven Systems for MMP Games

Sean Riley (NCsoft Corporation)
Massively Multiplayer Game Development, 2003.

Managing Game State Data Using a Database

Christian Lange (Origin Systems, Inc)
Massively Multiplayer Game Development, 2003.

A General Purpose Trigger System

Jeff Orkin (Monolith Productions)
AI Game Programming Wisdom, 2002.
Abstract: This article describes the implementation of a general-purpose centralized Trigger System. A Trigger System is used to keep track of events in the game world, and to optimize processing agents need to perform to recognize these events. Centralizing the Trigger System allows for culling by priority and proximity before delivering Trigger events to agents. The article and companion CD include working code for a stimulus-response Trigger System. Enhancements are discussed to extend the system to handle processing a grouping hierarchy of agents, in addition to individual agents.

Scripting: Overview and Code Generation

Lee Berger (Turbine Entertainment Software)
AI Game Programming Wisdom, 2002.

Scripting: The Interpreter Engine

Lee Berger (Turbine Entertainment Software)
AI Game Programming Wisdom, 2002.

Scripting: System Integration

Lee Berger (Turbine Entertainment Software)
AI Game Programming Wisdom, 2002.

Creating Scripting Languages for Non-Programmers

Falko Poiker (Relic Entertainment)
AI Game Programming Wisdom, 2002.

Scripting for Undefined Circumstances

Jonty Barnes (Lionhead Studios), Jason Hutchens (Amristar)
AI Game Programming Wisdom, 2002.
Abstract: Games are increasingly allowing the player to set the agenda. Want to while away hours mucking around with the game physics by throwing rocks into crowds of villagers? No problem! On the other hand, a strong storyline helps to inform the player of their goals, and provides a context for their actions. Traditionally, storylines in games have been advanced via cinematic sequences, and it is common for these to be displayed using the game engine. Can we resolve the conflict that occurs when we simultaneously afford the player the freedom to set the agenda and the game designers the ability to impose a storyline? What if a crucial moment in the story depends on the presence of the harmless little villager that the player unthinkingly threw into the ocean at the beginning of the game? Even worse, what if a non-player character under AI control intrudes into a cinematic sequence and begins to wreak havoc? In this article we discuss the features that were implemented in the game "Black & White" to allow the game designers to create storyline-advancing "Challenges" without compromising the unpredictable nature of the game.

The Perils of AI Scripting

Paul Tozour (Ion Storm Austin)
AI Game Programming Wisdom, 2002.
Abstract: Scripting is an enormously popular technique for developing game AI systems, but it can also be enormously dangerous. This article describes some of the considerations that you should think about very carefully before you jump on the scripting bandwagon, many of which you might not otherwise discover until it's too late. We also describe a number of the things that can go wrong when your lofty scripting language ambitions collide with the realities of game development.

How Not To Implement a Basic Scripting Language

Mark Brockington (BioWare), Mark Darrah (BioWare)
AI Game Programming Wisdom, 2002.
Abstract: This paper goes into some of the mistakes that were made while writing the scripting languages for Baldur's Gate and Neverwinter Nights. The four major points, which are covered with anecdotes: the lack of up-front design, ignoring early-adopter feedback, believing the code will only be used for one project, and believing the language will be used for one specific task.

Using Lex and Yacc to Parse Custom Data Files

Paul Kelly
Game Programming Gems 3, 2002.

A Flexible Text Parsing System

James Boer (Lithtech)
Game Programming Gems 2, 2001.

The Magic of Data-Driven Design

Steve Rabin (Nintendo of America)
Game Programming Gems, 2000.

A Generic Function-Binding Interface

Scott Bilas
Game Programming Gems, 2000.

40% off discount
"Latest from a must have series"
Game
Programming
Gems 7



"Cutting-edge graphics techniques"
GPU Gems 3


"Newest AI techniques from commercial games"
AI Game
Programming
Wisdom 4




Home