The creation of engaging, interactive virtual environments is a difficult task, but one that can be eased with the development of better software support. This paper proposes that a better understanding of the problem of building Dynamic, Interactive Virtual Environments must be developed. Equipped with an understanding of the design space of Dynamics, Dynamic Interaction, and Interactive Dynamics, the requirements for such a support system can be established. Finally, a system that supports the development of such environments is briefly presented, Functional Reactive Virtual Reality.

which was run in association with the IEEE Games Innovation Conference and the IEEE Symposium on Computational Intelligence and Games. The focus of the competition was on developing controllers that could play a version of Super Mario Bros as well as possible. We describe the motivations for holding this competition, the challenges associated with developing artificial intelligence for platform games, the software and API developed for the competition, the competition rules and organization, the submitted controllers and the results. We conclude the paper by discussing what the outcomes of the competition can teach us both about developing platform game AI and about organizing game AI competitions. The first two authors are the organizers of the competition, while the third author is the winner of the competition. Keywords: Mario, platform games, competitions, A*, evolutionary algorithms

Abstract. This paper introduces and motivates the application of parameterization to behavior trees. As a framework, behavior trees are becoming more commonly used for agent controllers in interactive game environments. We describe a way by which behavior trees can be authored for acting upon functions with arguments, as opposed to being limited to nonparametric tasks. We expand upon this idea to provide a method by which a subtree itself can be encapsulated with an exposed parameter interface through a lookup node, which enables code reuse in a manner already exploited by object oriented programming languages. Parameterization also allows us to recast Smart Events (a mechanism for co-opting agents to perform a desired activity) as behavior trees that can act generically upon groups of typed agents. Finally, we introduce a tool called Topiary, which enables the graphically-oriented authoring of behavior trees with this functionality as part of a broader testbed for agent simulation.

Abstract. Lua is a scripting language used in many industrial applications, with an emphasis on embedded systems and games. Two key points in the design of the language that led to its widely adoption are flexibility and small size. To achieve these two conflicting goals, the design emphasizes the use of few but powerful mechanisms, such as first-class functions, associative arrays, coroutines, and reflexive capabilities. As a consequence of this design, although Lua is primarily a procedural language, it is frequently used in several different programming paradigms, such as functional, object-oriented, goal-oriented, and concurrent programming, and also for data description. In this paper we discuss what mechanisms Lua features to achieve its flexibility and how programmers use them for different paradigms. 1

This paper presents a few heuristic path search algorithms to solve a physical puzzle consisting of 3D maze and a marble, simulated in a physically accurate environment. An intelligent agent must move the marble to a target cell by rotating the maze itself. The physical nature of the puzzle provides an interesting challenge for the agent attempting to solve it, since it does not have complete control over the effects of its actions, and is not able to predict with certainty what those effects will be. The algorithms presented are based on building a physical state graph from past observations and using a predictive utility function to estimate the closeness to the target. The implemented algorithms incorporate varying levels of knowledge of the maze's geometry and of the physics involved.

Abstract — Reactive agents are an important part of video games and numerous tools have emerged to facilitate the rapid construction of such agents. While the ability of the commonly used reactive techniques to express agent specifications is roughly equivalent, the authorial burden of constructing these specifications varies. In practice, this means that identical agent behavior may be more difficult to create in some architectures than others. In this paper we introduce the notion of representational complexity that relates to the authorial burden of constructing such agents and theoretically compare the representational complexity of finite state machines, behavior trees, and subsumption architectures. Our key finding is that hierarchical subsumption architectures have significantly lower representational complexity as compared to hierarchical finite state machines and behavior trees, which makes subsumption the best choice when developing authoring tools for non-expert users. I.

Abstract—There is a long tradition of developing games in which the difficulty level is dynamically adapted to the performance of human players. However, there has been less work on the creation of game systems that perform dynamic team-mate adaption – and even less on developing team-mate NPCs (Non Player Characters) that adaptively support players in the face of opponents that adaptively increase the difficulty for the player. This paper is based on preliminary research to identify the key elements involved in developing “buddy ” NPC team-mates that dynamically adapt to the needs and behaviors of human players while cooperating to compete against adaptive AI opponents. We discuss the computational and design challenges involved in developing such agents in the context of a simple test game called Capture the Gunner (CTG). The main contributions of the paper include: a proposed vocabulary and framework for understanding/modeling team-mate systems with adaptive difficulty, a particular technique for adaptive team-mate cooperation in the face of an adaptive opponent, and the identification of several significant new issues that arise in the process of developing computer games that involve adaptive NPC team-mates that cooperate with the player in the face of adaptive opponents. I.

Abstract — We consider the move generation in a modern board game where the set of all the possible moves is too large tactics that would generate enough combinations to provide strong opposition. The reduced search space is then traversed using the αβ search. We also propose a technique that allows us to remove the stochasticity from the search space. The model was tested in a game called Axis and Allies: a modern, turnbased, perfect information, non-deterministic, strategy board game. We first show that a tree search technique based on a restrained set of moves can beat the actual scripted AI engine —E.Z.FODDER. We can conclude from the experiments that searching deeper generates complex maneuvers which in turn significantly increase the likelihood of victory. I.

Abstract — Current approaches to organising units in strategic video games are typically implemented via static formations. Static formations are not capable of adapting effectively to opponent tactics. In this paper we discuss an approach to organising units by learning the effectiveness of a formation in actual play, and directly applying learned formations according to the classification of the opponent player. This approach to establish so-called dynamic formations, is tested in the ORTS game environment. From our results, we may conclude that the approach to established dynamic formations can be successfully applied in actual video-game environments. I.

This short paper proposes a simple extension of the celebrated MINIMAX algorithm used in zero-sum two-player games, called Rminimax. The Rminimax algorithm allows controlling the strength of an artificial rival by randomizing its strategy in an optimal way. In particular, the randomized shortest-path framework (Saerens et al., 2009) is applied for biasing the AI adversary towards worse or better solutions, therefore controlling its strength. This framework takes into account all possible strategies by computing an optimal trade-off between exploration (quantified by the spread entropy in the tree) and exploitation (quantified by the expected cost to an end game) of the game tree. As opposed to other tree-exploration techniques, this new algorithm considers complete paths of a tree (strategies) where a given entropy is spread. The optimal randomized strategy is efficiently computed by means of a simple recurrence relation while keeping the same complexity as the original MINIMAX. As a result, the Rminimax implements a non-deterministic, strength-adapted, AI opponent for board games in a principled way, thus avoiding the assumption of complete rationality. Simulations on two common games show that Rminimax behaves as expected. Keywords: minimax, randomized shortest-paths, two-player zero-sum perfect-information games. 1. General introduction Artificial intelligence (AI) techniques (see Luger, 2009, Nilsson, 1998, Russell and Norvig, 2003) are widely used in realistic-behavior video games (Millington, 2006, Smed, 2006). These methods aim, i.e., at finding paths for motion planning, collaborating between computer entities, learning from past experience, proposing game strategies, etc. The main focus of this paper is on finding strategies for two-player perfect information zero-sum games, such as chess and draughts. These games can be seen as a succession of plays which alternate from one player to another, and where the profit is maximized for the current player – therefore, minimized for the opponent. They are often solved thanks to the well-known MINIMAX algorithm