Music Tutor Using Tower Defense Strategy

Vivace is an online musical tower defense game using the tree-of-life metaphor, created using the Unity3D game engine. The game integrates basic music theory with the tower defense mechanic to motivate inspired learning. Vivace is different from most existing musical games, as it integrates notes and chords pedagogy in a puzzle-centric metaphor, as opposed to action/rhythm. This ensures that players undergo active learning by constantly applying and reiterating these musical concepts when tackling enemies and bosses through different levels. This article describes the procedural generation algorithms and game balancing strategies used to implement the game.

Modular Game Engine Design

The usage of software engineering principles in designing a game engine is discussed in this chapter using a simple tower defense game implemented using C# and the XNA Framework to illustrate usage of the engine. Essential functions, such as collision detection, input/output, graphics, object management, state management, and sound, will be implemented as independent units called managers. Because each manager is independent from the rest, essential development tasks such as implementing each manager and isolating bugs are much simpler.

Collision Detection in Video Games

This chapter will describe several methods of detecting collision events within a 3D environment. It will also discuss some of the bounding volumes, and their intersection tests that can be used to contain the graphical representation of objects in a video game. The first part of the chapter will cover the use of Axially Aligned Bounding Boxes (AABBs) and Radial Collision Volumes. The use of hierarchies with bounding volumes will be discussed. The next section of the chapter will focus on Object Oriented Bounding Boxes (OOBs). The third section is concerned with the Gilbert-Johnson-Keerthi distance algorithm (GJK). The last three sections will focus on ways of optimizing the collision detection process by culling unnecessary intersection tests through the use of type lists, sorted lists and spatial partitioning.

Evolving Bots’ AI in Unreal™

A bot is an autonomous enemy which tries to beat the human player and/or some other bots in a game. This chapter describes the design, implementation and results of a system to evolve bots inside the PC game Unreal™. The default artificial intelligence (AI) of this bot has been improved using two different evolutionary methods: genetic algorithms (GAs) and genetic programming (GP). The first one has been applied for tuning the parameters of the hard-coded values inside the bot AI code. The second method has been used to change the default set of rules (or states) that defines its behaviour. Moreover, the first approach has been considered at two levels: individual and team, performing different studies at the latter level, looking for the best cooperation scheme. Both techniques yield very good results, evolving bots (and teams) which are capable of defeating the default ones. The best results are obtained for the GA approach, since it just performs a refinement considering the default behaviour rules, while the GP method has to redefine the whole set of rules, so it is harder to get good results. This chapter presents one possibility of AI programming: building a better model from a standard one.

Practical Introduction to Rigid Body Linear Complementary Problem (LCP) Constraint Solvers

This chapter introduces Linear Complementary Problem (LCP) Solvers as a method for implementing real-time physics for games. This chapter explains principles and algorithms with practical examples and reasoning. When first investigating and writing a solver, one can easily become overwhelmed by the number of different methods and lack of implementation details, so this chapter will demonstrate the various methods from a practical point of view rather than a theoretical one; using code samples and real test cases to help understanding.

Behavior Trees

Behavior trees (BTs) are increasingly deployed in the games industry for decision making and control of non-player characters (NPCs, also named agents or actors) and gameplay. Behavior trees are incrementally created from reactive and goal-oriented behaviors by hierarchically compositing purposeful sub-behaviors. Composite behaviors (branches in the tree) decide which child behavior to run when and react to changing behavior execution states. Leaf nodes of the behavior tree check conditions, or control the execution of game state affecting actions. This chapter introduces a basic behavior tree concept, describes how behavior tree traversal drives NPC decision making via an example, and sketches a memory-compact implementation.

From a Game Story to a Real 2D Game

How does one design and implement a 2D game? Specifically, how does one teach students how to develop a game from an idea or a game story? A technical guide has been developed, which includes the modeling principle, the generic global software structure framework, and the incremental development strategy. The technical guide is introduced via the development of the example game Othello from a standalone version to a single player version and then to a networked version. The technical guide not only has been applied for gaming but also for implementing teaching tools with dynamic behaviors.

Collision Detection Using the GJK Algorithm

GJK is a fast and elegant collision detection algorithm. Originally designed to determine the distance between two convex shapes, it has been adapted to collision detection, continuous collision detection, and ray casting. Its versatility, speed, and compactness have allowed GJK to be one of the top choices of collision detection algorithms in a number of fields.

Application and Evaluation of Artificial Intelligence Algorithms for StarCraft

This chapter will discuss several algorithms and techniques used in artificial intelligence that can be applied to StarCraft (Blizzard, 2009) and other similar real-time strategy (RTS) games. A significant section of the chapter is devoted to teaching the reader how to use the Brood War API (Heinermann, 2011), BWAPI. This API allows developers to create agents that can play StarCraft with or without human interaction. Each section after the tutorial introduces an algorithm or technique, explains the relevant concepts, shows an example of its implementation in StarCraft, and evaluates its performance and applications. The algorithms and techniques covered include swarm intelligence, gathering algorithms, expert systems, and hill climbing. The example implementations are kept simple to allow readers to follow along and implement them as practice.

Nonmanipulable Collective Decision-Making for Games

This chapter explores a new approach that may be used in game development to help human players and/or non-player characters make collective decisions. The chapter describes how previous work can be applied to allow game players to form a consensus from a simple range of possible outcomes in such a way that no player can manipulate it at the expense of the other players. Then, the text extends that result and shows how nonmanipulable consensus can be found in higher-dimensional outcome spaces. The results may be useful when developing artificial intelligence for non-player characters or constructing frameworks to aid cooperation among human players.